[AArch64] Allow label arithmetic with add/sub/cmp

[rovka]

Summary

Allow instructions such as 'cmp w0, #(end - start)' by folding the
expression into a constant. For ELF, we fold only if the symbols are in
the same section. For MachO, we fold if the expression contains only
symbols that are not linker visible.

Fixes https://llvm.org/bugs/show_bug.cgi?id=18920

[rovka]

This is relaxing the error-checking in the asm parser quite significantly, so please look for any edge cases that I might have missed in the tests.
Also, I'm not sure this is doing the right thing for Darwin, any guidance there is more than welcome.
Thanks.

[rengolin]

@t.p.northover should have a look at the Darwin relocation, but the rest looks fine for me.

Nice set of tests, thanks!

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

3605

Maybe hacky, but can't you just count Loc[] and return 2 | 3 depending on the size?

[rovka]

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

3605

Right, I'll try to fix that.

[rovka]

Fixed the FIXME :)

[t.p.northover]

I think the MachO logic is pretty problematic:

• Because of .subsections_via_symbols a relocation would usually be needed for 2 assembler-local symbols if there's a linker-visible one between them.
• I think ARM64_RELOC_UNSIGNED is supposed to set all bits of the data it covers, not parse and interpret the instruction it's in the middle of.

I don't think there's an appropriate MachO relocation for this either, so we probably shouldn't try.

How does the ELF logic deal with attempts to perform subtractions across sections (the equivalent of the first MachO problem)?

[t.p.northover]

How does the ELF logic deal with attempts to perform subtractions across sections (the equivalent of the first MachO problem)?

Ah, I see there's logic in ELFObjectWriter.cpp and it really is checking the section, so MachO probably can't benefit.

We probably want to diagnose attempts in MachO where MCAssembler::getAtom is different (or null) for each symbol. With that restriction, we can even cope if one of them is the defining (visible) symbol of the atom.

[peter.smith]

I agree with Renato that the ELF side looks good.

Some suggestions the tests:

• All of the instructions are either add or cmp and all use the w registers. It may be worth varying these a bit more to cover the other cases within the switch(Inst.getOpcode())
• The labels used in the instructions look to be backwards references to labels already defined. It would be good to have some tests that use forward references to labels that are defined later in the file.
• All the Darwin tests are of the form (label1 - label2 + constant), are there other forms that can be expressed?

I note that the label expression must evaluate to a positive value. For example #(end - start) is ok, but #(start - end) or #-(end-start) is not. I don't think that there is much that you can do about this in the general case as IIRC the value of the expression is evaluated after the fragments are fixed and it is too late to easily change an ADD into a SUB or vice-versa.

To the best of my knowledge the Mach-O side looks ok, but I agree with Renato that someone more familar with Mach-O should take a look.

[rovka]

In D23834#524213, @t.p.northover wrote:

We probably want to diagnose attempts in MachO where MCAssembler::getAtom is different (or null) for each symbol. With that restriction, we can even cope if one of them is the defining (visible) symbol of the atom.

Ok, I'll try to investigate this some more. Thanks!

[rovka]

In D23834#524241, @peter.smith wrote:

I agree with Renato that the ELF side looks good.

Some suggestions the tests:

• All of the instructions are either add or cmp and all use the w registers. It may be worth varying these a bit more to cover the other cases within the switch(Inst.getOpcode())
• The labels used in the instructions look to be backwards references to labels already defined. It would be good to have some tests that use forward references to labels that are defined later in the file.

Those are very good suggestions, thanks.

• All the Darwin tests are of the form (label1 - label2 + constant), are there other forms that can be expressed?

I'm actually not proud of the Darwin tests, but I wanted to get an initial round of feedback before diving too deep. From what I've played with so far, we can't express (label1 - label2) >> constant (at least not out of the box; I don't know how we'd add support for that). Also, since we're generating relocations, we can't diagnose a lot of cases where we error out for ELF - I'm not sure what to do about these, at the moment I'm just hoping the linker will error out in a helpful way, or maybe magically handle them by moving atoms around.

I note that the label expression must evaluate to a positive value. For example #(end - start) is ok, but #(start - end) or #-(end-start) is not. I don't think that there is much that you can do about this in the general case as IIRC the value of the expression is evaluated after the fragments are fixed and it is too late to easily change an ADD into a SUB or vice-versa.

I should at least add a test-case diagnosing this though.

Thanks for the feedback.

[rovka]

Fix Darwin to allow label arithmetic only with assembler-private labels and update the Darwin tests accordingly. Also update the ELF tests as per the review comments.

[rovka]

Fix something embarrassing in a Darwin test (my bad).

[t.p.northover]

Thanks, the Darwin side looks less scary now.

[compnerd]

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

733

I think this is better written as:

if (auto *CE = dyn_cast<MCConstantExpr>(Expr))
  return CE->getValue() >= 0 && CE->getValue() <= 0xfff;
return true;

[rovka]

• Address Saleem's comment (thanks!)
• Get Darwin to error out on invalid values obtained from label arithmetic, i.e. negative values or values that are too large to fit. I did this by overriding the processFixupValue method in DarwinAArch64AsmBackend. It now calls adjustFixupValue with a legitimate MCContext, so it can dump errors (just like the ELF backend does).

[rovka]

Ping?

[rovka]

Move some of the tests from D23930 here (label arithmetic + lsl).

[rovka]

Ping again.

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

if (AArch64AsmParser::classifySymbolRef(Expr, ELFRefKind,
           || ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12
           || ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC
           || ELFRefKind == AArch64MCExpr::VK_TPREL_HI12
           || ELFRefKind == AArch64MCExpr::VK_TPREL_LO12
           || ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC
           || ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12;
     }
 
-    // Otherwise it should be a real immediate in range:
-    const MCConstantExpr *CE = cast<MCConstantExpr>(Expr);
+    // If it's a constant, it should be a real immediate in range:
+    if (auto *CE = dyn_cast<MCConstantExpr>(Expr))
       return CE->getValue() >= 0 && CE->getValue() <= 0xfff;
+
+    // If it's an expression, we hope for the best and let the fixup/relocation
+    // code deal with it.
+    return true;
   }
   bool isAddSubImmNeg() const {
     if (!isShiftedImm() && !isImm())
       return false;
 
     const MCExpr *Expr;
 
     // An ADD/SUB shifter is either 'lsl #0' or 'lsl #12'.
bool AArch64AsmParser::validateInstruction(MCInst &Inst,
   case AArch64::SUBXri: {
     // Annoyingly we can't do this in the isAddSubImm predicate, so there is
     // some slight duplication here.
     if (Inst.getOperand(2).isExpr()) {
       const MCExpr *Expr = Inst.getOperand(2).getExpr();
       AArch64MCExpr::VariantKind ELFRefKind;
       MCSymbolRefExpr::VariantKind DarwinRefKind;
       int64_t Addend;
-      if (!classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
-        return Error(Loc[2], "invalid immediate expression");
-      }
+      if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
 
         // Only allow these with ADDXri.
         if ((DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
              DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGEOFF) &&
             Inst.getOpcode() == AArch64::ADDXri)
           return false;
 
         // Only allow these with ADDXri/ADDWri
         if ((ELFRefKind == AArch64MCExpr::VK_LO12 ||
              ELFRefKind == AArch64MCExpr::VK_DTPREL_HI12 ||
              ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12 ||
              ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC ||
              ELFRefKind == AArch64MCExpr::VK_TPREL_HI12 ||
              ELFRefKind == AArch64MCExpr::VK_TPREL_LO12 ||
              ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC ||
              ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12) &&
             (Inst.getOpcode() == AArch64::ADDXri ||
              Inst.getOpcode() == AArch64::ADDWri))
           return false;
 
-      // Don't allow expressions in the immediate field otherwise
-      return Error(Loc[2], "invalid immediate expression");
+        // Don't allow symbol refs in the immediate field otherwise
+        // Note: Loc.back() may be Loc[1] or Loc[2] depending on the number of
+        // operands of the original instruction (i.e. 'add w0, w1, borked' vs
+        // 'cmp w0, 'borked')
+        return Error(Loc.back(), "invalid immediate expression");
+      }
+      // We don't validate more complex expressions here
     }
     return false;
   }
   default:
     return false;
   }
 }
 

lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp

if (!HasFP) {
         return CU::UNWIND_ARM64_MODE_DWARF;
 
       CompactUnwindEncoding |= CU::UNWIND_ARM64_MODE_FRAMELESS;
       CompactUnwindEncoding |= encodeStackAdjustment(StackSize);
     }
 
     return CompactUnwindEncoding;
   }
+
+  void processFixupValue(const MCAssembler &Asm, const MCAsmLayout &Layout,
+                         const MCFixup &Fixup, const MCFragment *DF,
+                         const MCValue &Target, uint64_t &Value,
+                         bool &IsResolved) override {
+    // Try to get the encoded value for the fixup as-if we're mapping it into
+    // the instruction. This allows adjustFixupValue() to issue a diagnostic
+    // if the value is invalid.
+    if (IsResolved)
+      (void)adjustFixupValue(Fixup, Value, &Asm.getContext());
+  }
 };
 
 } // end anonymous namespace
 
 namespace {
 
 class ELFAArch64AsmBackend : public AArch64AsmBackend {
 public:

lib/Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp

bool AArch64MachObjectWriter::getAArch64FixupKindMachOInfo(
   case AArch64::fixup_aarch64_ldst_imm12_scale1:
   case AArch64::fixup_aarch64_ldst_imm12_scale2:
   case AArch64::fixup_aarch64_ldst_imm12_scale4:
   case AArch64::fixup_aarch64_ldst_imm12_scale8:
   case AArch64::fixup_aarch64_ldst_imm12_scale16:
     Log2Size = llvm::Log2_32(4);
     switch (Sym->getKind()) {
     default:
-      llvm_unreachable("Unexpected symbol reference variant kind!");
+      return false;
     case MCSymbolRefExpr::VK_PAGEOFF:
       RelocType = unsigned(MachO::ARM64_RELOC_PAGEOFF12);
       return true;
     case MCSymbolRefExpr::VK_GOTPAGEOFF:
       RelocType = unsigned(MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12);
       return true;
     case MCSymbolRefExpr::VK_TLVPPAGEOFF:
       RelocType = unsigned(MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12);

test/MC/AArch64/basic-a64-diagnostics.s

 // CHECK-ERROR-NEXT:         mov x2, xsp, #123
 // CHECK-ERROR-NEXT:                 ^
 // CHECK-ERROR-NEXT: error: invalid operand for instruction
 // CHECK-ERROR-NEXT:         mov wsp, w27, #0xfff, lsl #12
 // CHECK-ERROR-NEXT:                       ^
 
         // A relocation should be provided for symbols
         add x3, x9, #variable
+        add x3, x9, #variable-16
 // CHECK-ERROR: error: expected compatible register, symbol or integer in range [0, 4095]
 // CHECK-ERROR-NEXT:         add x3, x9, #variable
 // CHECK-ERROR-NEXT:                      ^
+// CHECK-ERROR-NEXT: error: expected compatible register, symbol or integer in range [0, 4095]
+// CHECK-ERROR-NEXT:         add x3, x9, #variable-16
+// CHECK-ERROR-NEXT:                 ^
+
 
 
 //------------------------------------------------------------------------------
 // Add-subtract (shifted register)
 //------------------------------------------------------------------------------
 
         add wsp, w1, w2, lsr #3
         add x4, sp, x9, asr #5

test/MC/AArch64/label-arithmetic-darwin.s

+// RUN: llvm-mc -triple aarch64-darwin -filetype=obj %s -o - | llvm-objdump -r -d - | FileCheck %s
+// RUN: llvm-mc -triple aarch64-ios -filetype=obj %s -o - | llvm-objdump -r -d - | FileCheck %s
+
+visible:
+  .space 8
+Lstart:
+  .space 8
+Lend:
+  adds w0, w1, #(Lend - Lstart)
+  adds x0, x1, #(Lend - Lstart)
+  add w0, w1, #(Lend - Lstart)
+  add x0, x1, #(Lend - Lstart)
+  cmp w0, #(Lend - Lstart)
+  cmp x0, #(Lend - Lstart)
+  sub w0, w1, #(Lend - Lstart)
+  sub x0, x1, #(Lend - Lstart)
+  // CHECK: adds w0, w1, #8
+  // CHECK: adds x0, x1, #8
+  // CHECK: add w0, w1, #8
+  // CHECK: add x0, x1, #8
+  // CHECK: cmp w0, #8
+  // CHECK: cmp x0, #8
+  // CHECK: sub w0, w1, #8
+  // CHECK: sub x0, x1, #8
+
+  add w0, w1, #((Lend - Lstart) >> 2)
+  cmp w0, #((Lend - Lstart) >> 2)
+  // CHECK: add w0, w1, #2
+  // CHECK: cmp w0, #2
+
+  add w0, w1, #(Lend - Lstart + 12)
+  cmp w0, #(Lend - Lstart + 12)
+  // CHECK: add w0, w1, #20
+  // CHECK: cmp w0, #20
+
+  add w0, w1, #(Lforward - Lend)
+  cmp w0, #(Lforward - Lend)
+  // CHECK: add w0, w1, #320
+  // CHECK: cmp w0, #320
+
+  add w0, w1, #(Lstart - visible)
+  cmp w0, #(Lstart - visible)
+  // CHECK: add w0, w1, #8
+  // CHECK: cmp w0, #8
+
+// Add some filler so we don't have to modify #(Lforward - Lend) if we add more
+// instructions above
+Lfiller:
+  .space 320 - (Lfiller - Lend)
+
+Lforward:
+  .space 4
+  add w0, w1, #(. - Lforward)
+  cmp w0, #(. - Lforward)
+  // CHECK: add w0, w1, #4
+  // CHECK: cmp w0, #8

test/MC/AArch64/label-arithmetic-diags-darwin.s

+// RUN: not llvm-mc -triple aarch64-darwin -filetype=obj %s -o /dev/null 2>&1 | FileCheck %s
+// RUN: not llvm-mc -triple aarch64-ios -filetype=obj %s -o /dev/null 2>&1 | FileCheck %s
+
+Lstart:
+  .space 8
+Lend:
+  add w0, w1, #(Lend - external)
+  cmp w0, #(Lend - external)
+  // CHECK: error: unknown AArch64 fixup kind!
+  // CHECK-NEXT: add w0, w1, #(Lend - external)
+  // CHECK-NEXT: ^
+  // CHECK: error: unknown AArch64 fixup kind!
+  // CHECK-NEXT: cmp w0, #(Lend - external)
+  // CHECK-NEXT: ^
+
+  add w0, w1, #(Lend - var@TLVPPAGEOFF)
+  cmp w0, #(Lend - var@TLVPPAGEOFF)
+  // CHECK: error: unknown AArch64 fixup kind!
+  // CHECK-NEXT: add w0, w1, #(Lend - var@TLVPPAGEOFF)
+  // CHECK-NEXT: ^
+  // CHECK: error: unknown AArch64 fixup kind!
+  // CHECK-NEXT: cmp w0, #(Lend - var@TLVPPAGEOFF)
+  // CHECK-NEXT: ^
+
+  add w0, w1, #(Lstart - Lend)
+  cmp w0, #(Lstart - Lend)
+  // CHECK: error: fixup value out of range
+  // CHECK-NEXT: add w0, w1, #(Lstart - Lend)
+  // CHECK-NEXT: ^
+  // CHECK: error: fixup value out of range
+  // CHECK-NEXT: cmp w0, #(Lstart - Lend)
+  // CHECK-NEXT: ^
+
+  .space 5000
+Lfar:
+  add w0, w1, #(Lfar - Lend)
+  cmp w0, #(Lfar - Lend)
+  // CHECK: error: fixup value out of range
+  // CHECK-NEXT: add w0, w1, #(Lfar - Lend)
+  // CHECK-NEXT: ^
+  // CHECK: error: fixup value out of range
+  // CHECK-NEXT: cmp w0, #(Lfar - Lend)
+  // CHECK-NEXT: ^
+
+Lprivate1:
+  .space 8
+notprivate:
+  .space 8
+Lprivate2:
+  add w0, w1, #(Lprivate2 - Lprivate1)
+  cmp w0, #(Lprivate2 - Lprivate1)
+  // CHECK: error: unknown AArch64 fixup kind!
+  // CHECK-NEXT: add w0, w1, #(Lprivate2 - Lprivate1)
+  // CHECK-NEXT: ^
+  // CHECK: error: unknown AArch64 fixup kind!
+  // CHECK-NEXT: cmp w0, #(Lprivate2 - Lprivate1)
+  // CHECK-NEXT: ^
+
+  .section __TEXT, sec_y, regular, pure_instructions
+Lend_across_sec:
+  add w0, w1, #(Lend_across_sec - Lprivate2)
+  cmp w0, #(Lend_across_sec - Lprivate2)
+  // CHECK: error: unknown AArch64 fixup kind!
+  // CHECK-NEXT: add w0, w1, #(Lend_across_sec - Lprivate2)
+  // CHECK-NEXT: ^
+  // CHECK: error: unknown AArch64 fixup kind!
+  // CHECK-NEXT: cmp w0, #(Lend_across_sec - Lprivate2)
+  // CHECK-NEXT: ^

test/MC/AArch64/label-arithmetic-diags-elf.s

+// RUN: not llvm-mc -triple aarch64-elf -filetype=obj %s -o /dev/null 2>&1 | FileCheck %s
+
+  .section sec_x
+start:
+  .space 5000
+end:
+  add w0, w1, #(end - start)
+  cmp w0, #(end - start)
+  // CHECK: error: fixup value out of range
+  // CHECK-NEXT: add w0, w1, #(end - start)
+  // CHECK-NEXT: ^
+  // CHECK: error: fixup value out of range
+  // CHECK-NEXT: cmp w0, #(end - start)
+  // CHECK-NEXT: ^
+
+negative:
+  add w0, w1, #(end - negative)
+  cmp w0, #(end - negative)
+  // CHECK: error: fixup value out of range
+  // CHECK-NEXT: add w0, w1, #(end - negative)
+  // CHECK-NEXT: ^
+  // CHECK: error: fixup value out of range
+  // CHECK-NEXT: cmp w0, #(end - negative)
+  // CHECK-NEXT: ^
+
+  add w0, w1, #(end - external)
+  cmp w0, #(end - external)
+  // CHECK: error: symbol 'external' can not be undefined in a subtraction expression
+  // CHECK-NEXT: add w0, w1, #(end - external)
+  // CHECK-NEXT: ^
+  // CHECK: error: symbol 'external' can not be undefined in a subtraction expression
+  // CHECK-NEXT: cmp w0, #(end - external)
+  // CHECK-NEXT: ^
+
+  add w0, w1, #:lo12:external - end
+  cmp w0, #:lo12:external - end
+  // CHECK: error: Unsupported pc-relative fixup kind
+  // CHECK-NEXT: add w0, w1, #:lo12:external - end
+  // CHECK-NEXT: ^
+  // CHECK: error: Unsupported pc-relative fixup kind
+  // CHECK-NEXT: cmp w0, #:lo12:external - end
+  // CHECK-NEXT: ^
+
+  add w0, w1, #:got_lo12:external - end
+  cmp w0, #:got_lo12:external - end
+  // CHECK: error: Unsupported pc-relative fixup kind
+  // CHECK-NEXT: add w0, w1, #:got_lo12:external - end
+  // CHECK-NEXT: ^
+  // CHECK: error: Unsupported pc-relative fixup kind
+  // CHECK-NEXT: cmp w0, #:got_lo12:external - end
+  // CHECK-NEXT: ^
+
+  .section sec_y
+end_across_sec:
+  add w0, w1, #(end_across_sec - start)
+  cmp w0, #(end_across_sec - start)
+  // CHECK: error: Cannot represent a difference across sections
+  // CHECK-NEXT: add w0, w1, #(end_across_sec - start)
+  // CHECK-NEXT: ^
+  // CHECK: error: Cannot represent a difference across sections
+  // CHECK-NEXT: cmp w0, #(end_across_sec - start)
+  // CHECK-NEXT: ^
+
+  add w0, w1, #(sec_y - sec_x)
+  cmp w0, #(sec_y - sec_x)
+  // CHECK: error: symbol 'sec_x' can not be undefined in a subtraction expression
+  // CHECK-NEXT: add w0, w1, #(sec_y - sec_x)
+  // CHECK-NEXT: ^
+  // CHECK: error: symbol 'sec_x' can not be undefined in a subtraction expression
+  // CHECK-NEXT: cmp w0, #(sec_y - sec_x)
+  // CHECK-NEXT: ^

test/MC/AArch64/label-arithmetic-elf.s

+// RUN: llvm-mc -triple aarch64-elf -filetype=obj %s -o - | llvm-objdump -d - | FileCheck %s
+
+start:
+  .space 8
+end:
+  // CHECK-LABEL: end:
+
+  adds w0, w1, #(end - start)
+  adds x0, x1, #(end - start)
+  add w0, w1, #(end - start)
+  add x0, x1, #(end - start)
+  cmp w0, #(end - start)
+  cmp x0, #(end - start)
+  sub w0, w1, #(end - start)
+  sub x0, x1, #(end - start)
+  // CHECK: adds w0, w1, #8
+  // CHECK: adds x0, x1, #8
+  // CHECK: add w0, w1, #8
+  // CHECK: add x0, x1, #8
+  // CHECK: cmp w0, #8
+  // CHECK: cmp x0, #8
+  // CHECK: sub w0, w1, #8
+  // CHECK: sub x0, x1, #8
+
+  add w0, w1, #((end - start) >> 2)
+  cmp w0, #((end - start) >> 2)
+  // CHECK: add w0, w1, #2
+  // CHECK: cmp w0, #2
+
+  add w0, w1, #(end - start + 12)
+  cmp w0, #(end - start + 12)
+  // CHECK: add w0, w1, #20
+  // CHECK: cmp w0, #20
+
+  add w0, w1, #(forward - end)
+  cmp w0, #(forward - end)
+  // CHECK: add w0, w1, #320
+  // CHECK: cmp w0, #320
+
+// Add some filler so we don't have to modify #(forward - end) if we add more
+// instructions above
+.Lfiller:
+  .space 320 - (.Lfiller - end)
+
+forward:
+  .space 8
+
+.Lstart:
+  .space 8
+.Lend:
+  add w0, w1, #(.Lend - .Lstart)
+  cmp w0, #(.Lend - .Lstart)
+  // CHECK: add w0, w1, #8
+  // CHECK: cmp w0, #8
+
+.Lprivate1:
+  .space 8
+notprivate:
+  .space 8
+.Lprivate2:
+  add w0, w1, #(.Lprivate2 - .Lprivate1)
+  cmp w0, #(.Lprivate2 - .Lprivate1)
+  // CHECK: add w0, w1, #16
+  // CHECK: cmp w0, #16
+
+  .type foo, @function
+foo:
+  // CHECK-LABEL: foo:
+
+  add w0, w1, #(foo - .Lprivate2)
+  cmp w0, #(foo - .Lprivate2)
+  // CHECK: add w0, w1, #8
+  // CHECK: cmp w0, #8
+
+  ret
+
+  .type goo, @function
+goo:
+  // CHECK-LABEL: goo:
+
+  add w0, w1, #(goo - foo)
+  cmp w0, #(goo - foo)
+  // CHECK: add w0, w1, #12
+  // CHECK: cmp w0, #12
+
+  add w0, w1, #(. - goo)
+  cmp w0, #(. - goo)
+  // CHECK: add w0, w1, #8
+  // CHECK: cmp w0, #12
+
+  ret