Treat a narrowing PtrToInt like Trunc when generating asm

[mjhostet]

Summary

When printing assembly for PtrToInt, AsmPrinter::lowerConstant
incorrectly assumed that if PtrToInt was not converting to an
int with exactly the same number of bits, it must be widening
to a larger int. But this isn't necessarily true; PtrToInt can
also shrink the size, which is useful when you want to produce
a known 32-bit pointer on a 64-bit platform (on x86_64 ELF
this yields a R_X86_64_32 relocation).

The old behavior of falling through to the widening case for a
narrowing PtrToInt yields bogus assembly code like this, which
fails to assemble because the no-op bit and it accidentally
creates is not a valid relocation:

.long   a&-1

The fix is to treat a narrowing PtrToInt exactly the same as
it already treats Trunc: just emit the expression and let
the assembler deal with truncating it in the appropriate way.

[arsenm]

llvm/test/CodeGen/X86/ptrtoint-narrow.ll

2

Needs to check output. Usually for object emission, the disassembled output is checked

[mjhostet]

llvm/test/CodeGen/X86/ptrtoint-narrow.ll

2

Sure, I can check output if you want. The reason I didn't is because previously, llc printed the following error and exited with a error status when its internal assembler failed:

fatal error: error in backend: expected relocatable expression

The included test is testing that this no longer happens. I'll check the output too.

[mjhostet]

Check .s output in test, rather than llc exit status creating .o.

[mjhostet]

Simplify test

[mjhostet]

ping

[JohnReagan]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

2238

We made exactly this change in our out-of-tree backend that we use for OpenVMS x86. It was going to be one that we would push when we moved forward, but you beat me to it! Thanks!

[mjhostet]

ping 2

[hfinkel]

LGTM

[mjhostet]

Thanks @hfinkel! Could you please commit this for me?

[mjhostet]

ping 3: already approved, just need someone to commit for me. Thanks!

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

case Instruction::PtrToInt: {
     // changing the pointer to the appropriately sized integer type.
     Constant *Op = CE->getOperand(0);
     Type *Ty = CE->getType();
 
     const MCExpr *OpExpr = lowerConstant(Op);
 
     // We can emit the pointer value into this slot if the slot is an
     // integer slot equal to the size of the pointer.
-    if (DL.getTypeAllocSize(Ty) == DL.getTypeAllocSize(Op->getType()))
+    //
+    // If the pointer is larger than the resultant integer, then
+    // as with Trunc just depend on the assembler to truncate it.
+    if (DL.getTypeAllocSize(Ty) <= DL.getTypeAllocSize(Op->getType()))
       return OpExpr;
 
     // Otherwise the pointer is smaller than the resultant integer, mask off
     // the high bits so we are sure to get a proper truncation if the input is
     // a constant expr.
     unsigned InBits = DL.getTypeAllocSizeInBits(Op->getType());
     const MCExpr *MaskExpr = MCConstantExpr::create(~0ULL >> (64-InBits), Ctx);
     return MCBinaryExpr::createAnd(OpExpr, MaskExpr, Ctx);

llvm/test/CodeGen/X86/ptrtoint-narrow.ll

+; RUN: llc < %s -mtriple=x86_64-- -filetype=obj
+
+%struct.MyStruct = type { i32 }
+@ptr = external global i8, align 1
+@ref = global %struct.MyStruct { i32 trunc (i64 ptrtoint (i8* @ptr to i64) to i32) }, align 8