[SystemZ] Accept (. - 0x100000000) PCRel32 constants

[iii]

Summary

Clang does not accept instructions like brasl %r0,.-0x100000000,
because the second operand's right-hand-side (0x100000000) barely
misses the acceptable range. However, since it's being subtracted, it
makes sense to perform the range check on the negated value.

[uweigand]

LGTM, thanks!

llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp

SystemZAsmParser::parsePCRel(OperandVector &Operands, int64_t MinVal,
                              int64_t MaxVal, bool AllowTLS) {
   MCContext &Ctx = getContext();
   MCStreamer &Out = getStreamer();
   const MCExpr *Expr;
   SMLoc StartLoc = Parser.getTok().getLoc();
   if (getParser().parseExpression(Expr))
     return MatchOperand_NoMatch;
 
-  auto isOutOfRangeConstant = [&](const MCExpr *E) -> bool {
+  auto isOutOfRangeConstant = [&](const MCExpr *E, bool Negate) -> bool {
     if (auto *CE = dyn_cast<MCConstantExpr>(E)) {
       int64_t Value = CE->getValue();
+      if (Negate)
+        Value = -Value;
       if ((Value & 1) || Value < MinVal || Value > MaxVal)
         return true;
     }
     return false;
   };
 
   // For consistency with the GNU assembler, treat immediates as offsets
   // from ".".
   if (auto *CE = dyn_cast<MCConstantExpr>(Expr)) {
     if (isParsingHLASM()) {
       Error(StartLoc, "Expected PC-relative expression");
       return MatchOperand_ParseFail;
     }
-    if (isOutOfRangeConstant(CE)) {
+    if (isOutOfRangeConstant(CE, false)) {
       Error(StartLoc, "offset out of range");
       return MatchOperand_ParseFail;
     }
     int64_t Value = CE->getValue();
     MCSymbol *Sym = Ctx.createTempSymbol();
     Out.emitLabel(Sym);
     const MCExpr *Base = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None,
                                                  Ctx);
     Expr = Value == 0 ? Base : MCBinaryExpr::createAdd(Base, Expr, Ctx);
   }
 
   // For consistency with the GNU assembler, conservatively assume that a
   // constant offset must by itself be within the given size range.
   if (const auto *BE = dyn_cast<MCBinaryExpr>(Expr))
-    if (isOutOfRangeConstant(BE->getLHS()) ||
-        isOutOfRangeConstant(BE->getRHS())) {
+    if (isOutOfRangeConstant(BE->getLHS(), false) ||
+        isOutOfRangeConstant(BE->getRHS(),
+                             BE->getOpcode() == MCBinaryExpr::Sub)) {
       Error(StartLoc, "offset out of range");
       return MatchOperand_ParseFail;
     }
 
   // Optionally match :tls_gdcall: or :tls_ldcall: followed by a TLS symbol.
   const MCExpr *Sym = nullptr;
   if (AllowTLS && getLexer().is(AsmToken::Colon)) {
     Parser.Lex();

llvm/test/MC/SystemZ/insn-bad.s

#CHECK: jas %r0, 0x10000
   jas %r0, -0x100002
   jas %r0, -1
   jas %r0, 1
   jas %r0, 0x10000
 
 #CHECK: error: offset out of range
 #CHECK: brasl %r0, -0x1000000002
 #CHECK: error: offset out of range
+#CHECK: brasl %r0, .-0x1000000002
+#CHECK: error: offset out of range
 #CHECK: brasl %r0, -1
 #CHECK: error: offset out of range
 #CHECK: brasl %r0, 1
 #CHECK: error: offset out of range
 #CHECK: brasl %r0, 0x100000000
 #CHECK: error: offset out of range
 #CHECK: jasl  %r0, -0x1000000002
 #CHECK: error: offset out of range
+#CHECK: jasl  %r0, .-0x1000000002
+#CHECK: error: offset out of range
 #CHECK: jasl  %r0, -1
 #CHECK: error: offset out of range
 #CHECK: jasl  %r0, 1
 #CHECK: error: offset out of range
 #CHECK: jasl  %r0, 0x100000000
 
   brasl %r0, -0x1000000002
+  brasl %r0, .-0x1000000002
   brasl %r0, -1
   brasl %r0, 1
   brasl %r0, 0x100000000
   jasl  %r0, -0x1000000002
+  jasl  %r0, .-0x1000000002
   jasl  %r0, -1
   jasl  %r0, 1
   jasl  %r0, 0x100000000
 
 #CHECK: error: offset out of range
 #CHECK: brc 0, -0x100002
 #CHECK: error: offset out of range
 #CHECK: brc 0, -1

llvm/test/MC/SystemZ/insn-good.s

#CHECK:  fixup A - offset: 2, value: bar@PLT+2, kind: FK_390_PC16DBL
   jas %r15,bar@PLT
 
 #CHECK: brasl %r0, .[[LAB:L.*]]-4294967296 # encoding: [0xc0,0x05,A,A,A,A]
 #CHECK:  fixup A - offset: 2, value: (.[[LAB]]-4294967296)+2, kind: FK_390_PC32DBL
 #CHECK: brasl %r0, .[[LAB:L.*]]-4294967296 # encoding: [0xc0,0x05,A,A,A,A]
 #CHECK:  fixup A - offset: 2, value: (.[[LAB]]-4294967296)+2, kind: FK_390_PC32DBL
   brasl %r0, -0x100000000
   jasl  %r0, -0x100000000
+#CHECK: brasl %r0, .[[LAB:L.*]]-4294967296 # encoding: [0xc0,0x05,A,A,A,A]
+#CHECK:  fixup A - offset: 2, value: (.[[LAB]]-4294967296)+2, kind: FK_390_PC32DBL
+#CHECK: brasl %r0, .[[LAB:L.*]]-4294967296 # encoding: [0xc0,0x05,A,A,A,A]
+#CHECK:  fixup A - offset: 2, value: (.[[LAB]]-4294967296)+2, kind: FK_390_PC32DBL
+  brasl %r0, .-0x100000000
+  jasl  %r0, .-0x100000000
 #CHECK: brasl %r0, .[[LAB:L.*]]-2 # encoding: [0xc0,0x05,A,A,A,A]
 #CHECK:  fixup A - offset: 2, value: (.[[LAB]]-2)+2, kind: FK_390_PC32DBL
 #CHECK: brasl %r0, .[[LAB:L.*]]-2 # encoding: [0xc0,0x05,A,A,A,A]
 #CHECK:  fixup A - offset: 2, value: (.[[LAB]]-2)+2, kind: FK_390_PC32DBL
   brasl %r0, -2
   jasl  %r0, -2
 #CHECK: brasl %r0, .[[LAB:L.*]] # encoding: [0xc0,0x05,A,A,A,A]
 #CHECK:  fixup A - offset: 2, value: .[[LAB]]+2, kind: FK_390_PC32DBL