Lines Matching defs:immediate
188 int immediate;
192 immediate = (int) scaledDisplacement;
194 immediate = (int) displacement;
206 immediate = 0;
217 immediate = 0;
232 return AArch64Address.createAddress(addressingMode, newBase, newIndex, immediate, transferSize != 0, extendType);
300 int immediate = address.getImmediateRaw();
301 add(64, dst, address.getBase(), immediate);
333 * Generates a 64-bit immediate move code sequence.
339 // We have to move all non zero parts of the immediate in 16-bit chunks
357 * Loads immediate into register.
360 * @param imm immediate loaded into register.
370 // represent the lower 32 bits as a logical immediate we can create the lower 32-bit and
381 * Loads immediate into register.
384 * @param imm immediate loaded into register.
391 * Generates a 48-bit immediate move code sequence. The immediate may later be updated by
402 // We have to move all non zero parts of the immediate in 16-bit chunks
417 * Generates a 32-bit immediate move code sequence. The immediate may later be updated by
430 * @return Number of instructions necessary to load immediate into register.
438 // represent the lower 32 bits as a logical immediate we can create the lower 32-bit and
617 * dst = src + immediate.
622 * @param immediate 32-bit signed int
625 public void add(int size, Register dst, Register src, int immediate) {
627 if (immediate < 0) {
628 sub(size, dst, src, -immediate);
629 } else if (isAimm(immediate)) {
630 if (!(dst.equals(src) && immediate == 0)) {
631 super.add(size, dst, src, immediate);
633 } else if (immediate >= -(1 << 24) && immediate < (1 << 24)) {
634 super.add(size, dst, src, immediate & -(1 << 12));
635 super.add(size, dst, dst, immediate & ((1 << 12) - 1));
638 mov(dst, immediate);
649 * @param immediate arithmetic immediate.
652 public void adds(int size, Register dst, Register src, int immediate) {
654 if (immediate < 0) {
655 subs(size, dst, src, -immediate);
656 } else if (!(dst.equals(src) && immediate == 0)) {
657 super.adds(size, dst, src, immediate);
662 * dst = src - immediate.
667 * @param immediate 32-bit signed int
670 public void sub(int size, Register dst, Register src, int immediate) {
672 if (immediate < 0) {
673 add(size, dst, src, -immediate);
674 } else if (isAimm(immediate)) {
675 if (!(dst.equals(src) && immediate == 0)) {
676 super.sub(size, dst, src, immediate);
678 } else if (immediate >= -(1 << 24) && immediate < (1 << 24)) {
679 super.sub(size, dst, src, immediate & -(1 << 12));
680 super.sub(size, dst, dst, immediate & ((1 << 12) - 1));
683 mov(dst, immediate);
694 * @param immediate arithmetic immediate.
697 public void subs(int size, Register dst, Register src, int immediate) {
699 if (immediate < 0) {
700 adds(size, dst, src, -immediate);
701 } else if (!dst.equals(src) || immediate != 0) {
702 super.subs(size, dst, src, immediate);
795 * Add/subtract instruction encoding supports 12-bit immediate values.
797 * @param imm immediate value to be tested.
798 * @return true if immediate can be used directly for arithmetic instructions (add/sub), false
802 // If we have a negative immediate we just use the opposite operator. I.e.: x - (-5) == x +
808 * Compare instructions are add/subtract instructions and so support 12-bit immediate values.
810 * @param imm immediate value to be tested.
811 * @return true if immediate can be used directly with comparison instructions, false otherwise.
818 * Move wide immediate instruction encoding supports 16-bit immediate values which can be
821 * @return true if immediate can be moved directly into a register, false otherwise.
831 // // We can shift the necessary part of the immediate (i.e. everything between the first
974 * @param bimm logical immediate. See {@link AArch64Assembler.LogicalImmediateTable} for exact
1018 * @return True if the immediate can be used directly for logical 64-bit instructions.
1025 * @return True if the immediate can be used directly for logical 32-bit instructions.
1059 * @param imm immediate that is loaded into dst. If size is 32 only float immediates can be
1067 assert Double.doubleToRawLongBits(imm) == 0L : "-0.0 is no valid immediate.";
1076 * @return true if immediate can be loaded directly into floating-point register, false
1085 * @return true if immediate can be loaded directly into floating-point register, false
1140 * @param y comparison immediate, {@link #isComparisonImmediate(long)} has to be true for it.
1403 * @return true if immediate offset can be used in a single branch instruction.