AArch64MacroAssembler

java.lang.Object
- org.graalvm.compiler.asm.Assembler
- - org.graalvm.compiler.asm.aarch64.AArch64Assembler
  - - org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler

public class AArch64MacroAssembler
extends AArch64Assembler

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`AArch64MacroAssembler.AArch64ExceptionCode` Exception codes used when calling hlt instruction.
`static class`	`AArch64MacroAssembler.AdrpAddMacroInstruction`
`static class`	`AArch64MacroAssembler.AdrpLdrMacroInstruction`
`static class`	`AArch64MacroAssembler.MovSequenceAnnotation`
`class`	`AArch64MacroAssembler.ScratchRegister`

Nested classes/interfaces inherited from class org.graalvm.compiler.asm.aarch64.AArch64Assembler
AArch64Assembler.BarrierKind, AArch64Assembler.ConditionFlag, AArch64Assembler.DataCacheOperationType, AArch64Assembler.ExtendType, AArch64Assembler.Instruction, AArch64Assembler.InstructionType, AArch64Assembler.LogicalBitmaskImmediateEncoding, AArch64Assembler.PatchableCodeAnnotation, AArch64Assembler.PatcherUtil, AArch64Assembler.PrefetchMode, AArch64Assembler.ShiftType, AArch64Assembler.SingleInstructionAnnotation, AArch64Assembler.SystemHint, AArch64Assembler.SystemRegister

Nested classes/interfaces inherited from class org.graalvm.compiler.asm.Assembler
Assembler.CodeAnnotation, Assembler.InstructionCounter, Assembler.LabelHint

Field Summary

Fields
Modifier and Type Field and Description

AArch64ASIMDMacroAssembler neon

static int PREFERRED_BRANCH_TARGET_ALIGNMENT

static int PREFERRED_LOOP_ALIGNMENT
- Fields inherited from class org.graalvm.compiler.asm.aarch64.AArch64Assembler
  LoadFlag
- Fields inherited from class org.graalvm.compiler.asm.Assembler
  codePatchingAnnotationConsumer

Fields
Modifier and Type	Field and Description
`AArch64ASIMDMacroAssembler`	`neon`
`static int`	`PREFERRED_BRANCH_TARGET_ALIGNMENT`
`static int`	`PREFERRED_LOOP_ALIGNMENT`

Constructor Summary

Constructors
Constructor and Description

AArch64MacroAssembler(TargetDescription target)

Constructors
Constructor and Description
`AArch64MacroAssembler(TargetDescription target)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(int size, Register dst, Register src, int immediate)` dst = src + immediate.
`void`	`add(int size, Register dst, Register src, int immediate, Register scratch)` dst = src + immediate.
`void`	`add(int size, Register dst, Register src, long immediate)` dst = src + immediate.
`void`	`add(int size, Register dst, Register src1, Register src2)` dst = src1 + src2.
`void`	`add(int size, Register dst, Register src1, Register src2, AArch64Assembler.ShiftType shiftType, int shiftAmt)` dst = src1 + shiftType(src2, shiftAmt & (size - 1)).
`void`	`adds(int size, Register dst, Register src, int immediate)` dst = src + aimm and sets condition flags.
`void`	`adds(int size, Register dst, Register src1, Register src2)` dst = src1 + src2 and sets condition flags.
`void`	`adr(Register dst, Label label)`
`void`	`adrpAdd(Register dst)` Emits patchable adrp add sequence.
`void`	`adrpLdr(int srcSize, Register result, Register addressReg)` Emits patchable adrp ldr sequence.
`void`	`align(int modulus)` Aligns PC.
`void`	`and(int size, Register dst, Register src1, Register src2)` dst = src1 & src2.
`void`	`ands(int size, Register dst, Register x, Register y)` Sets condition flags according to result of x & y.
`void`	`asr(int size, Register dst, Register src, long shiftAmt)` dst = src >> (shiftAmt & log2(size)).
`void`	`bic(int size, Register dst, Register src, long imm)` dst = src & (~imm).
`void`	`bic(int size, Register dst, Register src1, Register src2)` dst = src1 & (~src2).
`void`	`bics(int size, Register dst, Register src1, Register src2)` dst = src1 & ~(src2) and sets condition flags.
`void`	`bind(Label l)`
`void`	`branchConditionally(AArch64Assembler.ConditionFlag condition)` Branches if condition is true.
`void`	`branchConditionally(AArch64Assembler.ConditionFlag condition, Label label)` Branches to label if condition is true.
`void`	`brk(AArch64MacroAssembler.AArch64ExceptionCode exceptionCode)` Monitor mode software breakpoint: exception routed to a debug monitor executing in a higher exception level.
`void`	`cacheWriteback(AArch64Address line)`
`void`	`cbnz(int size, Register cmp, Label label)` Compare register and branch if non-zero.
`void`	`cbz(int size, Register cmp, Label label)` Compare register and branch if zero.
`static int`	`clampShiftAmt(int size, long shiftAmt)` Clamps shiftAmt into range 0 <= shiftamt < size according to JLS.
`void`	`cmp(int size, Register x, Register y)` Compares x and y and sets condition flags.
`void`	`cmp(int size, Register x, Register y, AArch64Assembler.ExtendType extendType, int shiftAmt)` Compares x to (extendType(y) << imm) and sets condition flags.
`void`	`compare(int size, Register x, int y)` Compares x to y and sets condition flags.
`void`	`csdb()` Consumption of Speculative Data Barrier.
`void`	`cset(int size, Register dst, AArch64Assembler.ConditionFlag condition)` Conditional set.
`void`	`deadLoad(int srcSize, AArch64Address address, boolean tryMerge)` Performs a load to the zero register.
`void`	`emitJumpTableOffset(Label jumpTable, Label entryTarget)` Emits offset to store in JumpTable for given JumpTable start (`jumpTable`) and jump target (`entryTarget`).
`void`	`ensureUniquePC()` Same as `AArch64MacroAssembler.nop()`.
`void`	`eon(int size, Register dst, Register src1, Register src2)` dst = src1 ^ (~src2).
`void`	`eor(int size, Register dst, Register src1, Register src2)` dst = src1 ^ src2.
`void`	`fldr(int size, Register rt, AArch64Address address)` Floating point load.
`void`	`fldr(int size, Register rt, AArch64Address address, boolean tryMerge)` Floating point load.
`void`	`fmov(int size, Register dst, double imm)` C7.2.132 Floating-point move immediate (scalar) Move immediate into floating-point register.
`void`	`fmov(int size, Register dst, Register src)` Moves integer to float, float to integer, or float to float.
`void`	`fstr(int size, Register rt, AArch64Address address)` Floating point store.
`void`	`fstr(int size, Register rt, AArch64Address address, boolean tryMerge)` Floating point store.
`void`	`fullSystemBarrier()` Ensures current execution state is committed before continuing.
`int`	`getPCRelativeOffset(Label label)` Retrieves pc relative offset between current position and provided bound label.
`AArch64Address`	`getPlaceholder(int instructionStartPosition)` Returns a target specific placeholder address that can be used for code patching.
`AArch64MacroAssembler.ScratchRegister`	`getScratchRegister()`
`void`	`hlt(AArch64MacroAssembler.AArch64ExceptionCode exceptionCode)` Halting mode software breakpoint: Enters halting mode debug state if enabled, else treated as UNALLOCATED instruction.
`void`	`illegal()` Create an invalid instruction to signify an error.
`static boolean`	`isBranchImmediateOffset(long imm)`
`static boolean`	`isComparisonImmediate(long imm)` Compare instructions are add/subtract instructions and so support unsigned 12-bit immediate values (optionally left-shifted by 12).
`static boolean`	`isDoubleImmediate(double imm)`
`static boolean`	`isFloatImmediate(float imm)`
`boolean`	`isImmLoadStoreMerged()`
`static boolean`	`isLogicalImmediate(int size, long imm)`
`void`	`jmp()` Immediate jump instruction fixed up by the runtime.
`void`	`jmp(Label label)` Jumps to label.
`void`	`jmp(Register dest)` Jump to address in dest.
`void`	`ldr(int srcSize, Register rt, AArch64Address address)` Loads a srcSize value from address into rt.
`void`	`ldr(int srcSize, Register rt, AArch64Address address, boolean tryMerge)` Loads a srcSize value from address into rt.
`void`	`ldrs(int targetSize, int srcSize, Register rt, AArch64Address address)` Loads a srcSize value from address into rt sign-extending it if necessary.
`void`	`loadAddress(Register dst, AArch64Address address)` Loads memory address into register.
`void`	`loadAlignedAddress(int bitMemoryTransferSize, Register dst, Register base, long displacement)` Loads requested base + displacement into destination register while also confirming the displacement is properly aligned for the provided transfer size.
`void`	`loadExclusive(int size, Register rt, Register rn, boolean acquire)` Load exclusive.
`void`	`lsl(int size, Register dst, Register src, long shiftAmt)` C.6.2.179 Logical Shift Left (immediate).
`void`	`lsr(int size, Register dst, Register src, long shiftAmt)` C.6.2.182 Logical Shift Right (immediate).
`AArch64Address`	`makeAddress(int bitMemoryTransferSize, Register base, int displacement)` Generates an address of the form `base + displacement`.
`AArch64Address`	`makeAddress(int bitMemoryTransferSize, Register base, long displacement)` Generates an address of the form `base + displacement`.
`AArch64Address`	`makeAddress(int bitMemoryTransferSize, Register base, long displacement, Register scratchReg)` Returns an AArch64Address pointing to `base + displacement`.
`void`	`mneg(int size, Register dst, Register src1, Register src2)` dst = 0 - src1 * src2.
`void`	`mov(int size, Register dst, Register src)` Generates a move between two general purpose registers.
`void`	`mov(Register dst, int imm)` Loads immediate into register.
`void`	`mov(Register dst, int imm, boolean needsImmAnnotation)` Loads immediate into register.
`void`	`mov(Register dst, long imm)` Loads immediate into register.
`void`	`mov(Register dst, long imm, boolean needsImmAnnotation)` Loads immediate into register.
`void`	`movNarrowAddress(Register dst, long imm)` Generates a 32-bit immediate move code sequence.
`void`	`movNativeAddress(Register dst, long imm)` Generates a 48-bit immediate move code sequence.
`void`	`movNativeAddress(Register dst, long imm, boolean needsImmAnnotation)` Generates a 48-bit immediate move code sequence.
`void`	`mul(int size, Register dst, Register src1, Register src2)` dst = src1 * src2.
`void`	`neg(int size, Register dst, Register src)` dst = -src.
`void`	`neg(int size, Register dst, Register src, AArch64Assembler.ShiftType shiftType, int shiftAmt)` dst = -(shiftType(src, shiftAmt & (size - 1))).
`void`	`nop()` Executes no-op instruction.
`void`	`not(int size, Register dst, Register src)` dst = ~src.
`void`	`orn(int size, Register dst, Register src1, Register src2)` dst = src1 \| (~src2).
`void`	`orr(int size, Register dst, Register src1, Register src2)` dst = src1 \| src2.
`protected void`	`patchJumpTarget(int patchPos, int jumpTarget)` Patches jump targets when label gets bound.
`void`	`pause()`
`void`	`popcnt(int size, Register dst, Register src, Register vreg)` Count the set bits of src register.
`void`	`ror(int size, Register dst, Register src, long shiftAmt)` Rotate right (immediate).
`void`	`ror(int size, Register dst, Register src1, Register src2)` C.6.2.228 Rotate right (register).
`void`	`smnegl(Register dst, Register src1, Register src2)` Signed multiply-negate long.
`void`	`smulh(int size, Register dst, Register src1, Register src2)` Signed multiply high.
`void`	`smull(Register dst, Register src1, Register src2)` Signed multiply long.
`void`	`storeExclusive(int size, Register rs, Register rt, Register rn, boolean release)` Store exclusive.
`void`	`str(int destSize, Register rt, AArch64Address address)` Stores register rt into memory pointed by address.
`void`	`str(int destSize, Register rt, AArch64Address address, boolean tryMerge)` Stores register rt into memory pointed by address.
`void`	`sub(int size, Register dst, Register src, int immediate)` dst = src - immediate.
`void`	`sub(int size, Register dst, Register src, int immediate, Register scratch)` dst = src - immediate.
`void`	`sub(int size, Register dst, Register src1, Register src2)` dst = src1 - src2.
`void`	`sub(int size, Register dst, Register src1, Register src2, AArch64Assembler.ShiftType shiftType, int shiftAmt)` dst = src1 - shiftType(src2, shiftAmt & (size-1)) and sets condition flags.
`void`	`subs(int size, Register dst, Register src, int immediate)` dst = src - aimm and sets condition flags.
`void`	`subs(int size, Register dst, Register src1, Register src2)` dst = src1 - src2 and sets condition flags.
`void`	`sxt(int destSize, int srcSize, Register dst, Register src)` Sign-extend value from src into dst.
`void`	`tbnz(Register cmp, int uimm6, Label label)` Test a single bit and branch if the bit is nonzero.
`void`	`tbz(Register cmp, int uimm6, Label label)` Test a single bit and branch if the bit is zero.
`AArch64Address`	`tryMakeAddress(int bitMemoryTransferSize, Register base, long displacement)` Generates an address of the form `base + displacement`.
`void`	`tst(int size, Register x, long bimm)` C6.2.334 Test bits (immediate). Sets condition flags according to the result of x & bimm
`void`	`tst(int size, Register x, Register y)` C6.2.335 Test bits (register). Sets condition flags according to the result of x & y
`void`	`umulh(int size, Register dst, Register src1, Register src2)` Unsigned multiply high.

Methods inherited from class org.graalvm.compiler.asm.aarch64.AArch64Assembler
add, adds, adds, adr, adr, adrp, and, ands, annotatePatchingImmediate, b, b, b, b, b, bfm, bic, bics, bl, blr, br, brk, cas, cbnz, cbnz, cbz, cbz, ccmp, clrex, cls, clz, csel, csinc, csneg, dc, dmb, dsb, eon, eor, extr, fabs, fadd, fccmp, fcmp, fcmpe, fcmpeZero, fcmpZero, fcsel, fcvt, fcvtzs, fdiv, fldp, fmadd, fmax, fmin, fmovCpu2Fpu, fmovFpu2Cpu, fmovFpu2Fpu, fmsub, fmul, fneg, frintm, frintn, frintp, frintz, fsqrt, fstp, fsub, getFeatures, getFlags, getLog2TransferSize, hint, hlt, insertLdpStp, isAddSubtractImmediate, isb, isFlagSet, ldadd, ldar, ldaxr, ldp, ldrHelper, ldxr, madd, movk, movn, movz, mrs, msr, msub, orn, orr, prfm, rbit, ret, rev, rorv, sbfm, scvtf, sdiv, smaddl, smsubl, smulh, stlr, stlxr, stp, stxr, sub, subs, subs, supports, swp, tbnz, tbnz, tbz, tbz, ubfm, udiv, umaddl, umulh

Methods inherited from class org.graalvm.compiler.asm.Assembler
close, copy, createLabelName, emitByte, emitByte, emitInt, emitInt, emitLong, emitLong, emitShort, emitShort, emitString, emitString, emitString0, getByte, getInstructionCounter, getInt, getMachineCodeCallDisplacementOffset, getReturnAddressSize, getShort, inlineObjects, isTargetMP, nameOf, position, requestLabelHint, reset, setCodePatchingAnnotationConsumer

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - neon
```
public final AArch64ASIMDMacroAssembler neon
```
  - PREFERRED_LOOP_ALIGNMENT
```
public static final int PREFERRED_LOOP_ALIGNMENT
```
    See Also:
    
    Constant Field Values
  - PREFERRED_BRANCH_TARGET_ALIGNMENT
```
public static final int PREFERRED_BRANCH_TARGET_ALIGNMENT
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - AArch64MacroAssembler
```
public AArch64MacroAssembler(TargetDescription target)
```
- Method Detail
  - getScratchRegister
```
public AArch64MacroAssembler.ScratchRegister getScratchRegister()
```
  - bind
```
public void bind(Label l)
```
    Overrides:
    
    bind in class Assembler
  - getPCRelativeOffset
```
public int getPCRelativeOffset(Label label)
```
    Retrieves pc relative offset between current position and provided bound label.
  - tryMakeAddress
```
public AArch64Address tryMakeAddress(int bitMemoryTransferSize,
                                     Register base,
                                     long displacement)
```
    Generates an address of the form base + displacement. Will return null if displacement cannot be represented directly as an immediate address.
    
    Parameters:
    
    bitMemoryTransferSize - bit size of memory operation this address will be used in.
    
    base - general purpose register. May not be null or the zero register.
    
    displacement - arbitrary displacement added to base.
    
    Returns:
    
    AArch64Address referencing memory at base + displacement.
  - makeAddress
```
public AArch64Address makeAddress(int bitMemoryTransferSize,
                                  Register base,
                                  long displacement,
                                  Register scratchReg)
```
    Returns an AArch64Address pointing to base + displacement. Will fail if displacement cannot be represented directly as an immediate address and a scratch register is not provided.
    
    Parameters:
    
    bitMemoryTransferSize - bit size of memory operation this address will be used in.
    
    scratchReg - scratch register to use if immediate addressing mode cannot be used. Should be set to zero-register if scratch register is not available.
  - makeAddress
```
public AArch64Address makeAddress(int bitMemoryTransferSize,
                                  Register base,
                                  long displacement)
```
    Generates an address of the form base + displacement. Will fail if displacement cannot be represented directly as an immediate address.
    
    Parameters:
    
    bitMemoryTransferSize - bit size of memory operation this address will be used in.
    
    base - general purpose register. May not be null or the zero register.
    
    displacement - arbitrary displacement added to base.
    
    Returns:
    
    AArch64Address referencing memory at base + displacement.
  - makeAddress
```
public AArch64Address makeAddress(int bitMemoryTransferSize,
                                  Register base,
                                  int displacement)
```
    Generates an address of the form base + displacement. Will fail if displacement cannot be represented directly as an immediate address.
    
    Specified by:
    
    makeAddress in class Assembler
    
    Parameters:
    
    bitMemoryTransferSize - bit size of memory operation this address will be used in.
    
    base - general purpose register. May not be null or the zero register.
    
    displacement - arbitrary displacement added to base.
    
    Returns:
    
    AArch64Address referencing memory at base + displacement.
  - loadAddress
```
public void loadAddress(Register dst,
                        AArch64Address address)
```
    Loads memory address into register.
    
    Parameters:
    
    dst - general purpose register. May not be null, zero-register or stackpointer.
    
    address - address whose value is loaded into dst. May not be null, POST_INDEXED, PRE_INDEXED, PAIR_SIGNED_SCALED, PAIR_POST_INDEXED, or PAIR PRE_INDEXED.
  - loadAlignedAddress
```
public void loadAlignedAddress(int bitMemoryTransferSize,
                               Register dst,
                               Register base,
                               long displacement)
```
    Loads requested base + displacement into destination register while also confirming the displacement is properly aligned for the provided transfer size.
  - isImmLoadStoreMerged
```
public boolean isImmLoadStoreMerged()
```
  - mov
```
public void mov(int size,
                Register dst,
                Register src)
```
    Generates a move between two general purpose registers.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
  - mov
```
public void mov(Register dst,
                int imm)
```
    Loads immediate into register.
    
    Parameters:
    
    dst - general purpose register. May not be null, zero-register or stackpointer.
    
    imm - immediate loaded into register.
  - mov
```
public void mov(Register dst,
                long imm)
```
    Loads immediate into register.
    
    Parameters:
    
    dst - general purpose register. May not be null, zero-register or stackpointer.
    
    imm - immediate loaded into register.
  - mov
```
public void mov(Register dst,
                int imm,
                boolean needsImmAnnotation)
```
    Loads immediate into register.
    
    Parameters:
    
    dst - general purpose register. May not be null, zero-register or stackpointer.
    
    imm - immediate loaded into register.
    
    needsImmAnnotation - Flag to signal of the immediate value should be annotated.
  - mov
```
public void mov(Register dst,
                long imm,
                boolean needsImmAnnotation)
```
    Loads immediate into register.
    
    Parameters:
    
    dst - general purpose register. May not be null, zero-register or stackpointer.
    
    imm - immediate loaded into register.
    
    needsImmAnnotation - Flag to signal of the immediate value should be annotated.
  - movNativeAddress
```
public void movNativeAddress(Register dst,
                             long imm)
```
    Generates a 48-bit immediate move code sequence. The immediate may later be updated by HotSpot. In AArch64 mode the virtual address space is 48-bits in size, so we only need three instructions to create a patchable instruction sequence that can reach anywhere.
    
    Parameters:
    
    dst - general purpose register. May not be null, stackpointer or zero-register.
    
    imm -
  - movNativeAddress
```
public void movNativeAddress(Register dst,
                             long imm,
                             boolean needsImmAnnotation)
```
    Generates a 48-bit immediate move code sequence. The immediate may later be updated by HotSpot. In AArch64 mode the virtual address space is 48-bits in size, so we only need three instructions to create a patchable instruction sequence that can reach anywhere.
    
    Parameters:
    
    dst - general purpose register. May not be null, stackpointer or zero-register.
    
    imm - The immediate address
    
    needsImmAnnotation - Flag to signal of the immediate value should be annotated.
  - movNarrowAddress
```
public void movNarrowAddress(Register dst,
                             long imm)
```
    Generates a 32-bit immediate move code sequence. The immediate may later be updated by HotSpot.
    
    Parameters:
    
    dst - general purpose register. May not be null, stackpointer or zero-register.
    
    imm -
  - ldrs
```
public void ldrs(int targetSize,
                 int srcSize,
                 Register rt,
                 AArch64Address address)
```
    Loads a srcSize value from address into rt sign-extending it if necessary.
    
    Overrides:
    
    ldrs in class AArch64Assembler
    
    Parameters:
    
    targetSize - size of target register in bits. Must be 32 or 64.
    
    srcSize - size of memory read in bits. Must be 8, 16 or 32 and smaller or equal to targetSize.
    
    rt - general purpose register. May not be null or stackpointer.
    
    address - all addressing modes allowed. May not be null.
  - deadLoad
```
public void deadLoad(int srcSize,
                     AArch64Address address,
                     boolean tryMerge)
```
    Performs a load to the zero register. The effect of this is to test the address's page permissions.
  - ldr
```
public void ldr(int srcSize,
                Register rt,
                AArch64Address address)
```
    Loads a srcSize value from address into rt.
    
    Overrides:
    
    ldr in class AArch64Assembler
    
    Parameters:
    
    srcSize - size of memory read in bits. Must be 8, 16 or 32 and smaller or equal to targetSize.
    
    rt - general purpose register. May not be null or stackpointer.
    
    address - all addressing modes allowed. May not be null.
  - ldr
```
public void ldr(int srcSize,
                Register rt,
                AArch64Address address,
                boolean tryMerge)
```
    Loads a srcSize value from address into rt. In addition, if requested, tries to merge two adjacent loads into one ldp.
  - str
```
public void str(int destSize,
                Register rt,
                AArch64Address address)
```
    Stores register rt into memory pointed by address.
    
    Overrides:
    
    str in class AArch64Assembler
    
    Parameters:
    
    destSize - number of bits written to memory. Must be 8, 16, 32 or 64.
    
    rt - general purpose register. May not be null or stackpointer.
    
    address - all addressing modes allowed. May not be null.
  - str
```
public void str(int destSize,
                Register rt,
                AArch64Address address,
                boolean tryMerge)
```
    Stores register rt into memory pointed by address. In addition, if requested, tries to merge two adjacent stores into one stp.
  - fldr
```
public void fldr(int size,
                 Register rt,
                 AArch64Address address)
```
    Floating point load.
    
    Overrides:
    
    fldr in class AArch64Assembler
    
    Parameters:
    
    size - number of bits read from memory into rt. Must be 8, 16, 32, 64 or 128.
    
    rt - floating point register. May not be null.
    
    address - all addressing modes allowed. May not be null.
  - fldr
```
public void fldr(int size,
                 Register rt,
                 AArch64Address address,
                 boolean tryMerge)
```
    Floating point load. In addition, if requested, tries to merge two adjacent loads into one fldp.
  - fstr
```
public void fstr(int size,
                 Register rt,
                 AArch64Address address)
```
    Floating point store.
    
    Overrides:
    
    fstr in class AArch64Assembler
    
    Parameters:
    
    size - number of bits read from memory into rt. Must be 32 or 64.
    
    rt - floating point register. May not be null.
    
    address - all addressing modes allowed. May not be null.
  - fstr
```
public void fstr(int size,
                 Register rt,
                 AArch64Address address,
                 boolean tryMerge)
```
    Floating point store. In addition, if requested, tries to merge two adjacent stores into one stp.
  - loadExclusive
```
public void loadExclusive(int size,
                          Register rt,
                          Register rn,
                          boolean acquire)
```
    Load exclusive. Natural alignment of address is required.
    
    Parameters:
    
    size - size of memory read in bits. Must be 8, 16, 32 or 64.
    
    rt - general purpose register. May not be null or stackpointer.
    
    rn - general purpose register.
    
    acquire - memory model flag. Decide whether the load has acquire semantics.
  - storeExclusive
```
public void storeExclusive(int size,
                           Register rs,
                           Register rt,
                           Register rn,
                           boolean release)
```
    Store exclusive. Natural alignment of address is required. rs and rt may not point to the same register.
    
    Parameters:
    
    size - size of bits written to memory. Must be 8, 16, 32 or 64.
    
    rs - general purpose register. Set to exclusive access status. 0 means success, everything else failure. May not be null, or stackpointer.
    
    rt - general purpose register. May not be null or stackpointer.
    
    rn - general purpose register.
    
    release - memory model flag. Decide whether the store has release semantics.
  - cset
```
public void cset(int size,
                 Register dst,
                 AArch64Assembler.ConditionFlag condition)
```
    Conditional set. dst = 1 if condition else 0.
    
    Parameters:
    
    dst - general purpose register. May not be null or stackpointer.
    
    condition - any condition. May not be null.
  - add
```
public void add(int size,
                Register dst,
                Register src1,
                Register src2)
```
    dst = src1 + src2.
    
    Overrides:
    
    add in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null. Can be zr if src1 != sp. Can be sp if src1 != zr.
    
    src1 - general purpose register. May not be null. Can be zr if dst != sp. Can be sp if dst != zr.
    
    src2 - general purpose register. May not be null or stackpointer.
  - adds
```
public void adds(int size,
                 Register dst,
                 Register src1,
                 Register src2)
```
    dst = src1 + src2 and sets condition flags.
    
    Overrides:
    
    adds in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null.
    
    src2 - general purpose register. May not be null or stackpointer.
  - sub
```
public void sub(int size,
                Register dst,
                Register src1,
                Register src2)
```
    dst = src1 - src2.
    
    Overrides:
    
    sub in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null. Can be zr if src1 != sp. Can be sp if src1 != zr.
    
    src1 - general purpose register. May not be null. Can be zr if dst != sp. Can be sp if dst != zr.
    
    src2 - general purpose register. May not be null or stackpointer.
  - subs
```
public void subs(int size,
                 Register dst,
                 Register src1,
                 Register src2)
```
    dst = src1 - src2 and sets condition flags.
    
    Overrides:
    
    subs in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null.
    
    src2 - general purpose register. May not be null or stackpointer.
  - add
```
public void add(int size,
                Register dst,
                Register src1,
                Register src2,
                AArch64Assembler.ShiftType shiftType,
                int shiftAmt)
```
    dst = src1 + shiftType(src2, shiftAmt & (size - 1)).
    
    Overrides:
    
    add in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null or stackpointer.
    
    src2 - general purpose register. May not be null or stackpointer.
    
    shiftType - any type but ROR.
    
    shiftAmt - arbitrary shift amount.
  - sub
```
public void sub(int size,
                Register dst,
                Register src1,
                Register src2,
                AArch64Assembler.ShiftType shiftType,
                int shiftAmt)
```
    dst = src1 - shiftType(src2, shiftAmt & (size-1)) and sets condition flags.
    
    Overrides:
    
    sub in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null or stackpointer.
    
    src2 - general purpose register. May not be null or stackpointer.
    
    shiftType - any type but ROR.
    
    shiftAmt - arbitrary shift amount.
  - neg
```
public void neg(int size,
                Register dst,
                Register src)
```
    dst = -src.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src - general purpose register. May not be null or stackpointer.
  - neg
```
public void neg(int size,
                Register dst,
                Register src,
                AArch64Assembler.ShiftType shiftType,
                int shiftAmt)
```
    dst = -(shiftType(src, shiftAmt & (size - 1))).
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src - general purpose register. May not be null or stackpointer.
    
    shiftType - right or left shift, arithmetic or logical.
    
    shiftAmt - number of shift bits. Has to be between 0 and (size - 1).
  - add
```
public void add(int size,
                Register dst,
                Register src,
                int immediate,
                Register scratch)
```
    dst = src + immediate. If immediate >= 2^24, then this method uses the scratch register to hold the immediate value.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or zero-register.
    
    src - general purpose register. May not be null or zero-register.
    
    immediate - 32-bit signed int.
    
    scratch - general purpose register to hold immediate value (if necessary).
  - add
```
public void add(int size,
                Register dst,
                Register src,
                int immediate)
```
    dst = src + immediate. If immediate >= 2^24, then this method assumes dst and src are not the same register.
    
    Overrides:
    
    add in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or zero-register.
    
    src - general purpose register. May not be null or zero-register.
    
    immediate - 32-bit signed int
  - add
```
public void add(int size,
                Register dst,
                Register src,
                long immediate)
```
    dst = src + immediate.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or zero-register.
    
    src - general purpose register. May not be null or zero-register.
    
    immediate - 64-bit signed int
  - adds
```
public void adds(int size,
                 Register dst,
                 Register src,
                 int immediate)
```
    dst = src + aimm and sets condition flags.
    
    Overrides:
    
    adds in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src - general purpose register. May not be null or zero-register.
    
    immediate - arithmetic immediate.
  - sub
```
public void sub(int size,
                Register dst,
                Register src,
                int immediate,
                Register scratch)
```
    dst = src - immediate. If immediate >= 2^24, then this method uses the scratch register to hold the immediate value.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or zero-register.
    
    src - general purpose register. May not be null or zero-register.
    
    immediate - 32-bit signed int.
    
    scratch - general purpose register to hold immediate value (if necessary).
  - sub
```
public void sub(int size,
                Register dst,
                Register src,
                int immediate)
```
    dst = src - immediate. If immediate >= 2^24, then this method assumes dst and src are not the same register.
    
    Overrides:
    
    sub in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or zero-register.
    
    src - general purpose register. May not be null or zero-register.
    
    immediate - 32-bit signed int
  - subs
```
public void subs(int size,
                 Register dst,
                 Register src,
                 int immediate)
```
    dst = src - aimm and sets condition flags.
    
    Overrides:
    
    subs in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src - general purpose register. May not be null or zero-register.
    
    immediate - arithmetic immediate.
  - mul
```
public void mul(int size,
                Register dst,
                Register src1,
                Register src2)
```
    dst = src1 * src2.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or the stackpointer.
    
    src1 - general purpose register. May not be null or the stackpointer.
    
    src2 - general purpose register. May not be null or the stackpointer.
  - mneg
```
public void mneg(int size,
                 Register dst,
                 Register src1,
                 Register src2)
```
    dst = 0 - src1 * src2.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or the stackpointer.
    
    src1 - general purpose register. May not be null or the stackpointer.
    
    src2 - general purpose register. May not be null or the stackpointer.
  - umulh
```
public void umulh(int size,
                  Register dst,
                  Register src1,
                  Register src2)
```
    Unsigned multiply high. dst = (src1 * src2) >> size
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or the stackpointer.
    
    src1 - general purpose register. May not be null or the stackpointer.
    
    src2 - general purpose register. May not be null or the stackpointer.
  - smulh
```
public void smulh(int size,
                  Register dst,
                  Register src1,
                  Register src2)
```
    Signed multiply high. dst = (src1 * src2) >> size
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or the stackpointer.
    
    src1 - general purpose register. May not be null or the stackpointer.
    
    src2 - general purpose register. May not be null or the stackpointer.
  - smull
```
public void smull(Register dst,
                  Register src1,
                  Register src2)
```
    Signed multiply long. xDst = wSrc1 * wSrc2
    
    Parameters:
    
    dst - 64-bit general purpose register. May not be null or the stackpointer.
    
    src1 - 32-bit general purpose register. May not be null or the stackpointer.
    
    src2 - 32-bit general purpose register. May not be null or the stackpointer.
  - smnegl
```
public void smnegl(Register dst,
                   Register src1,
                   Register src2)
```
    Signed multiply-negate long. xDst = -(wSrc1 * wSrc2)
    
    Parameters:
    
    dst - 64-bit general purpose register. May not be null or the stackpointer.
    
    src1 - 32-bit general purpose register. May not be null or the stackpointer.
    
    src2 - 32-bit general purpose register. May not be null or the stackpointer.
  - isComparisonImmediate
```
public static boolean isComparisonImmediate(long imm)
```
    Compare instructions are add/subtract instructions and so support unsigned 12-bit immediate values (optionally left-shifted by 12).
    
    Parameters:
    
    imm - immediate value to be tested.
    
    Returns:
    
    true if immediate can be used directly with comparison instructions, false otherwise.
  - lsl
```
public void lsl(int size,
                Register dst,
                Register src,
                long shiftAmt)
```
    C.6.2.179 Logical Shift Left (immediate).
    dst = src << (shiftAmt & (size - 1)).
    
    Overrides:
    
    lsl in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null, stackpointer or zero-register.
    
    src - general purpose register. May not be null, stackpointer or zero-register.
    
    shiftAmt - amount by which src is shifted.
  - lsr
```
public void lsr(int size,
                Register dst,
                Register src,
                long shiftAmt)
```
    C.6.2.182 Logical Shift Right (immediate).
    dst = src >>> (shiftAmt & (size - 1)).
    
    Overrides:
    
    lsr in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null, stackpointer or zero-register.
    
    src - general purpose register. May not be null, stackpointer or zero-register.
    
    shiftAmt - amount by which src is shifted.
  - asr
```
public void asr(int size,
                Register dst,
                Register src,
                long shiftAmt)
```
    dst = src >> (shiftAmt & log2(size)).
    
    Overrides:
    
    asr in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null, stackpointer or zero-register.
    
    src - general purpose register. May not be null, stackpointer or zero-register.
    
    shiftAmt - amount by which src is shifted.
  - ror
```
public void ror(int size,
                Register dst,
                Register src1,
                Register src2)
```
    C.6.2.228 Rotate right (register). dst = rotateRight(src1, (src2 & (size - 1))).
    Preferred alias for RORV (C6.2.228)
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null or stackpointer.
    
    src2 - general purpose register. It holds a shift amount from 0 to (size - 1) in its bottom 5 bits. May not be null or stackpointer.
  - ror
```
public void ror(int size,
                Register dst,
                Register src,
                long shiftAmt)
```
    Rotate right (immediate). dst = rotateRight(src1, shift).
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src - general purpose register. May not be null or stackpointer.
    
    shiftAmt - amount by which src is rotated. The value depends on the instruction variant, it can be 0 to (size - 1).
  - clampShiftAmt
```
public static int clampShiftAmt(int size,
                                long shiftAmt)
```
    Clamps shiftAmt into range 0 <= shiftamt < size according to JLS.
    
    Parameters:
    
    size - size of operation. Must be 32 or 64.
    
    shiftAmt - arbitrary shift amount.
    
    Returns:
    
    value between 0 and size - 1 inclusive that is equivalent to shiftAmt according to JLS.
  - and
```
public void and(int size,
                Register dst,
                Register src1,
                Register src2)
```
    dst = src1 & src2.
    
    Overrides:
    
    and in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null or stackpointer.
    
    src2 - general purpose register. May not be null or stackpointer.
  - eor
```
public void eor(int size,
                Register dst,
                Register src1,
                Register src2)
```
    dst = src1 ^ src2.
    
    Overrides:
    
    eor in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null or stackpointer.
    
    src2 - general purpose register. May not be null or stackpointer.
  - orr
```
public void orr(int size,
                Register dst,
                Register src1,
                Register src2)
```
    dst = src1 | src2.
    
    Overrides:
    
    orr in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null or stackpointer.
    
    src2 - general purpose register. May not be null or stackpointer.
  - bic
```
public void bic(int size,
                Register dst,
                Register src1,
                Register src2)
```
    dst = src1 & (~src2).
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null or stackpointer.
    
    src2 - general purpose register. May not be null or stackpointer.
  - bic
```
public void bic(int size,
                Register dst,
                Register src,
                long imm)
```
    dst = src & (~imm).
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src - general purpose register. May not be null or stackpointer.
    
    imm - immediate to encode.
  - eon
```
public void eon(int size,
                Register dst,
                Register src1,
                Register src2)
```
    dst = src1 ^ (~src2).
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null or stackpointer.
    
    src2 - general purpose register. May not be null or stackpointer.
  - orn
```
public void orn(int size,
                Register dst,
                Register src1,
                Register src2)
```
    dst = src1 | (~src2).
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null or stackpointer.
    
    src2 - general purpose register. May not be null or stackpointer.
  - not
```
public void not(int size,
                Register dst,
                Register src)
```
    dst = ~src.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src - general purpose register. May not be null or stackpointer.
  - bics
```
public void bics(int size,
                 Register dst,
                 Register src1,
                 Register src2)
```
    dst = src1 & ~(src2) and sets condition flags.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stackpointer.
    
    src1 - general purpose register. May not be null or stackpointer.
    
    src2 - general purpose register. May not be null or stackpointer.
  - sxt
```
public void sxt(int destSize,
                int srcSize,
                Register dst,
                Register src)
```
    Sign-extend value from src into dst.
    
    Parameters:
    
    destSize - destination register size. Must be 32 or 64.
    
    srcSize - source register size. Must be smaller than destSize.
    
    dst - general purpose register. May not be null, stackpointer or zero-register.
    
    src - general purpose register. May not be null, stackpointer or zero-register.
  - isLogicalImmediate
```
public static boolean isLogicalImmediate(int size,
                                         long imm)
```
    Parameters:
    
    size - size of instruction immediate will be encoded within.
    
    imm - immediate to encode.
    
    Returns:
    
    True if the immediate can be directly encoded within a logical immediate.
  - fmov
```
public void fmov(int size,
                 Register dst,
                 Register src)
```
    Moves integer to float, float to integer, or float to float. Does not support integer to integer moves.
    
    Overrides:
    
    fmov in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - Either floating-point or general-purpose register. If general-purpose register may not be stackpointer or zero register. Cannot be null in any case.
    
    src - Either floating-point or general-purpose register. If general-purpose register may not be stackpointer. Cannot be null in any case.
  - fmov
```
public void fmov(int size,
                 Register dst,
                 double imm)
```
    Description copied from class: AArch64Assembler
    
    C7.2.132 Floating-point move immediate (scalar) Move immediate into floating-point register.
    
    Overrides:
    
    fmov in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - floating point register. May not be null.
    
    imm - immediate that is loaded into dst. If size is 32 only float immediates can be loaded, i.e. (float) imm == imm must be true. In all cases isFloatImmediate, respectively #isDoubleImmediate must be true depending on size.
  - isDoubleImmediate
```
public static boolean isDoubleImmediate(double imm)
```
    Returns:
    
    true if immediate can be loaded directly into floating-point register, false otherwise.
  - isFloatImmediate
```
public static boolean isFloatImmediate(float imm)
```
    Returns:
    
    true if immediate can be loaded directly into floating-point register, false otherwise.
  - cmp
```
public void cmp(int size,
                Register x,
                Register y)
```
    Compares x and y and sets condition flags.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    x - general purpose register. May not be null.
    
    y - general purpose register. May not be null or stackpointer.
  - compare
```
public void compare(int size,
                    Register x,
                    int y)
```
    Compares x to y and sets condition flags.
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    x - general purpose register. May not be null or zero-register.
    
    y - comparison immediate, AArch64MacroAssembler.isComparisonImmediate(long) has to be true for it.
  - cmp
```
public void cmp(int size,
                Register x,
                Register y,
                AArch64Assembler.ExtendType extendType,
                int shiftAmt)
```
    Compares x to (extendType(y) << imm) and sets condition flags. This is an alias for AArch64Assembler.subs(int, Register, Register, Register, ExtendType, int).
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    x - general purpose register. May not be null or zero-register.
    
    y - general purpose register. May not be null or stackpointer.
    
    extendType - defines how y is extended to be the same size as x.
    
    shiftAmt - must be in range 0 to 4.
  - ands
```
public void ands(int size,
                 Register dst,
                 Register x,
                 Register y)
```
    Sets condition flags according to result of x & y.
    
    Overrides:
    
    ands in class AArch64Assembler
    
    Parameters:
    
    size - register size. Has to be 32 or 64.
    
    dst - general purpose register. May not be null or stack-pointer.
    
    x - general purpose register. May not be null or stackpointer.
    
    y - general purpose register. May not be null or stackpointer.
  - tst
```
public void tst(int size,
                Register x,
                long bimm)
```
    C6.2.334 Test bits (immediate).
    Sets condition flags according to the result of x & bimm
  - tst
```
public void tst(int size,
                Register x,
                Register y)
```
    C6.2.335 Test bits (register).
    Sets condition flags according to the result of x & y
  - adr
```
public void adr(Register dst,
                Label label)
```
  - cbnz
```
public void cbnz(int size,
                 Register cmp,
                 Label label)
```
    Compare register and branch if non-zero.
    
    Parameters:
    
    size - Instruction size in bits. Should be either 32 or 64.
    
    cmp - general purpose register. May not be null, zero-register or stackpointer.
    
    label - Can only handle 21-bit word-aligned offsets for now. May be unbound. Non null.
  - cbz
```
public void cbz(int size,
                Register cmp,
                Label label)
```
    Compare register and branch if zero.
    
    Parameters:
    
    size - Instruction size in bits. Should be either 32 or 64.
    
    cmp - general purpose register. May not be null, zero-register or stackpointer.
    
    label - Can only handle 21-bit word-aligned offsets for now. May be unbound. Non null.
  - tbnz
```
public void tbnz(Register cmp,
                 int uimm6,
                 Label label)
```
    Test a single bit and branch if the bit is nonzero.
    
    Parameters:
    
    cmp - general purpose register. May not be null, zero-register or stackpointer.
    
    uimm6 - Unsigned 6-bit bit index.
    
    label - Can only handle 16-bit word-aligned offsets for now. May be unbound. Non null.
  - tbz
```
public void tbz(Register cmp,
                int uimm6,
                Label label)
```
    Test a single bit and branch if the bit is zero.
    
    Parameters:
    
    cmp - general purpose register. May not be null, zero-register or stackpointer.
    
    uimm6 - Unsigned 6-bit bit index.
    
    label - Can only handle 16-bit word-aligned offsets for now. May be unbound. Non null.
  - branchConditionally
```
public void branchConditionally(AArch64Assembler.ConditionFlag condition,
                                Label label)
```
    Branches to label if condition is true.
    
    Parameters:
    
    condition - any condition value allowed. Non null.
    
    label - Can only handle 21-bit word-aligned offsets for now. May be unbound. Non null.
  - branchConditionally
```
public void branchConditionally(AArch64Assembler.ConditionFlag condition)
```
    Branches if condition is true. Address of jump is patched up by the runtime.
    
    Parameters:
    
    condition - any condition value allowed. Non null.
  - jmp
```
public void jmp(Label label)
```
    Jumps to label. param label Can only handle signed 28-bit offsets. May be unbound. Non null.
    
    Specified by:
    
    jmp in class Assembler
  - jmp
```
public void jmp(Register dest)
```
    Jump to address in dest.
    
    Specified by:
    
    jmp in class Assembler
    
    Parameters:
    
    dest - General purpose register. May not be null, zero-register or stackpointer.
  - jmp
```
public void jmp()
```
    Immediate jump instruction fixed up by the runtime.
  - emitJumpTableOffset
```
public void emitJumpTableOffset(Label jumpTable,
                                Label entryTarget)
```
    Emits offset to store in JumpTable for given JumpTable start (jumpTable) and jump target (entryTarget).
  - isBranchImmediateOffset
```
public static boolean isBranchImmediateOffset(long imm)
```
    Returns:
    
    true if immediate offset can be used in a single branch instruction.
  - hlt
```
public void hlt(AArch64MacroAssembler.AArch64ExceptionCode exceptionCode)
```
    Halting mode software breakpoint: Enters halting mode debug state if enabled, else treated as UNALLOCATED instruction.
    
    Parameters:
    
    exceptionCode - exception code specifying why halt was called. Non null.
  - brk
```
public void brk(AArch64MacroAssembler.AArch64ExceptionCode exceptionCode)
```
    Monitor mode software breakpoint: exception routed to a debug monitor executing in a higher exception level.
    
    Parameters:
    
    exceptionCode - exception code specifying why break was called. Non null.
  - pause
```
public void pause()
```
  - nop
```
public void nop()
```
    Executes no-op instruction. No registers or flags are updated, except for PC.
  - csdb
```
public void csdb()
```
    Consumption of Speculative Data Barrier. This is a memory barrier that controls speculative execution and data value prediction.
  - fullSystemBarrier
```
public void fullSystemBarrier()
```
    Ensures current execution state is committed before continuing.
  - ensureUniquePC
```
public void ensureUniquePC()
```
    Same as AArch64MacroAssembler.nop().
    
    Specified by:
    
    ensureUniquePC in class Assembler
  - illegal
```
public void illegal()
```
    Create an invalid instruction to signify an error.
  - align
```
public void align(int modulus)
```
    Aligns PC.
    
    Specified by:
    
    align in class Assembler
    
    Parameters:
    
    modulus - Has to be positive multiple of 4.
  - patchJumpTarget
```
protected void patchJumpTarget(int patchPos,
                               int jumpTarget)
```
    Patches jump targets when label gets bound.
    
    Specified by:
    
    patchJumpTarget in class Assembler
  - getPlaceholder
```
public AArch64Address getPlaceholder(int instructionStartPosition)
```
    Description copied from class: Assembler
    
    Returns a target specific placeholder address that can be used for code patching.
    
    Specified by:
    
    getPlaceholder in class Assembler
    
    Parameters:
    
    instructionStartPosition - The start of the instruction, i.e., the value that is used as the key for looking up placeholder patching information.
  - adrpAdd
```
public void adrpAdd(Register dst)
```
    Emits patchable adrp add sequence.
  - popcnt
```
public void popcnt(int size,
                   Register dst,
                   Register src,
                   Register vreg)
```
    Count the set bits of src register.
    
    Parameters:
    
    size - src register size. Has to be 32 or 64.
    
    dst - general purpose register. Should not be null or zero-register.
    
    src - general purpose register. Should not be null.
    
    vreg - SIMD register. Should not be null.
  - cacheWriteback
```
public void cacheWriteback(AArch64Address line)
```
  - adrpLdr
```
public void adrpLdr(int srcSize,
                    Register result,
                    Register addressReg)
```
    Emits patchable adrp ldr sequence.

Class AArch64MacroAssembler

Nested Class Summary

Nested classes/interfaces inherited from class org.graalvm.compiler.asm.aarch64.AArch64Assembler

Nested classes/interfaces inherited from class org.graalvm.compiler.asm.Assembler

Field Summary

Fields inherited from class org.graalvm.compiler.asm.aarch64.AArch64Assembler

Fields inherited from class org.graalvm.compiler.asm.Assembler

Constructor Summary

Method Summary

Methods inherited from class org.graalvm.compiler.asm.aarch64.AArch64Assembler

Methods inherited from class org.graalvm.compiler.asm.Assembler

Methods inherited from class java.lang.Object

Field Detail

neon

PREFERRED_LOOP_ALIGNMENT

PREFERRED_BRANCH_TARGET_ALIGNMENT

Constructor Detail

AArch64MacroAssembler

Method Detail

getScratchRegister

bind

getPCRelativeOffset

tryMakeAddress

makeAddress

makeAddress

makeAddress

loadAddress

loadAlignedAddress

isImmLoadStoreMerged

mov

mov

mov

mov

mov

movNativeAddress

movNativeAddress

movNarrowAddress

ldrs

deadLoad

ldr

ldr

str

str

fldr

fldr

fstr

fstr

loadExclusive

storeExclusive

cset

add

adds

sub

subs

add

sub

neg

neg

add

add

add

adds

sub

sub

subs

mul

mneg

umulh

smulh

smull

smnegl

isComparisonImmediate

lsl

lsr

asr

ror

ror

clampShiftAmt

and

eor