[SystemZ] Improve handling of huge PC relative immediate offsets.

[jonpa]

Summary

Demand that an immediate offset to a PC relative address fits in 32 bits, or else load it into a register and perform a separate add.

Verify in the assembler that such immediate offsets fit the bitwidth.

Even though the final address of a Load Address Relative Long may fit in 32 bits even with >32 bit offset (depending on where the symbol lives relative to PC), the GNU toolchain demands the offset by itself to be in range. This patch adapts the same behavior for llvm.

[uweigand]

LGTM, thanks!

[jonpa]

Thanks for review.
commit 580310f

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 {
+    if (auto *CE = dyn_cast<MCConstantExpr>(E)) {
+      int64_t Value = CE->getValue();
+      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)) {
-    int64_t Value = CE->getValue();
-    if ((Value & 1) || Value < MinVal || Value > MaxVal) {
+    if (isOutOfRangeConstant(CE)) {
       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())) {
+      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();
 
     if (Parser.getTok().isNot(AsmToken::Identifier)) {
       Error(Parser.getTok().getLoc(), "unexpected token");
       return MatchOperand_ParseFail;

llvm/lib/Target/SystemZ/SystemZISelLowering.cpp

SDValue SystemZTargetLowering::lowerGlobalAddress(GlobalAddressSDNode *Node,
   SDLoc DL(Node);
   const GlobalValue *GV = Node->getGlobal();
   int64_t Offset = Node->getOffset();
   EVT PtrVT = getPointerTy(DAG.getDataLayout());
   CodeModel::Model CM = DAG.getTarget().getCodeModel();
 
   SDValue Result;
   if (Subtarget.isPC32DBLSymbol(GV, CM)) {
+    if (isInt<32>(Offset)) {
       // Assign anchors at 1<<12 byte boundaries.
       uint64_t Anchor = Offset & ~uint64_t(0xfff);
       Result = DAG.getTargetGlobalAddress(GV, DL, PtrVT, Anchor);
       Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
 
-    // The offset can be folded into the address if it is aligned to a halfword.
+      // The offset can be folded into the address if it is aligned to a
+      // halfword.
       Offset -= Anchor;
       if (Offset != 0 && (Offset & 1) == 0) {
-      SDValue Full = DAG.getTargetGlobalAddress(GV, DL, PtrVT, Anchor + Offset);
+        SDValue Full =
+          DAG.getTargetGlobalAddress(GV, DL, PtrVT, Anchor + Offset);
         Result = DAG.getNode(SystemZISD::PCREL_OFFSET, DL, PtrVT, Full, Result);
         Offset = 0;
       }
     } else {
+      // Conservatively load a constant offset greater than 32 bits into a
+      // register below.
+      Result = DAG.getTargetGlobalAddress(GV, DL, PtrVT);
+      Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
+    }
+  } else {
     Result = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0, SystemZII::MO_GOT);
     Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
     Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Result,
                          MachinePointerInfo::getGOT(DAG.getMachineFunction()));
   }
 
   // If there was a non-zero offset that we didn't fold, create an explicit
   // addition for it.

llvm/test/CodeGen/SystemZ/la-05.ll

+; Test that a huge address offset is loaded into a register and then added
+; separately.
+;
+; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
+
+@a = common dso_local global i32 0, align 4
+
+define i64 @f1() {
+; CHECK-LABEL: f1:
+; CHECK: llihl   %r0, 829
+; CHECK: oilf    %r0, 4294966308
+; CHECK: larl    %r2, a
+; CHECK: agr     %r2, %r0
+; CHECK: br      %r14
+  ret i64 add (i64 ptrtoint (i32* @a to i64), i64 3564822854692)
+}
+
+define signext i32 @f2() {
+; CHECK-LABEL: f2:
+; CHECK: llihl   %r0, 829
+; CHECK: oilf    %r0, 4294966308
+; CHECK: larl    %r1, a
+; CHECK: agr     %r1, %r0
+; CHECK: lgf     %r2, 0(%r1)
+; CHECK: br      %r14
+entry:
+  %0 = load i32, i32* inttoptr (i64 add (i64 ptrtoint (i32* @a to i64),
+                                i64 3564822854692) to i32*)
+  ret i32 %0
+}
+

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

 #CHECK: error: offset out of range
 #CHECK: larl  %r0, -0x1000000002
 #CHECK: error: offset out of range
 #CHECK: larl  %r0, -1
 #CHECK: error: offset out of range
 #CHECK: larl  %r0, 1
 #CHECK: error: offset out of range
 #CHECK: larl  %r0, 0x100000000
+#CHECK: error: offset out of range
+#CHECK: larl  %r1, __unnamed_1+3564822854692
 
   larl  %r0, -0x1000000002
   larl  %r0, -1
   larl  %r0, 1
   larl  %r0, 0x100000000
+  larl  %r1, __unnamed_1+3564822854692
 
 #CHECK: error: invalid use of indexed addressing
 #CHECK: lasp  160(%r1,%r15),160(%r15)
 #CHECK: error: invalid operand
 #CHECK: lasp  -1(%r1),160(%r15)
 #CHECK: error: invalid operand
 #CHECK: lasp  4096(%r1),160(%r15)
 #CHECK: error: invalid operand

 #CHECK: error: offset out of range
 #CHECK: lrl %r0, -0x1000000002
 #CHECK: error: offset out of range
 #CHECK: lrl %r0, -1
 #CHECK: error: offset out of range
 #CHECK: lrl %r0, 1
 #CHECK: error: offset out of range
 #CHECK: lrl %r0, 0x100000000
+#CHECK: error: offset out of range
+#CHECK: lrl %r1, __unnamed_1+3564822854692
 
   lrl %r0, -0x1000000002
   lrl %r0, -1
   lrl %r0, 1
   lrl %r0, 0x100000000
+  lrl %r1, __unnamed_1+3564822854692
 
 #CHECK: error: invalid operand
 #CHECK: lrv %r0, -524289
 #CHECK: error: invalid operand
 #CHECK: lrv %r0, 524288
 
   lrv %r0, -524289
   lrv %r0, 524288