Add path to lower addrspacecasts in constant exprs for __ptr32/__ptr64.

[akhuang]

Summary

This is for addrspacecasts to ms ptr32 and ptr64 pointers that
occur in global variables. It adds an X86 override for
AsmPrinter::emitGlobalConstant that deals with zext to 64-bit pointers
and trunc when casting to 32-bit pointers.

Bug: https://bugs.llvm.org/show_bug.cgi?id=51888

[arsenm]

llvm/lib/Target/X86/X86AsmPrinter.cpp

145

Would it be easier to just add a new callback to handle addrspacecast instead of having to reproduce some of the generic logic and call into the default implementation

[JohnReagan]

llvm/lib/Target/X86/X86AsmPrinter.cpp

138

What would the sign-extended form look like? Is it much harder to add? I thought I remember you have both signed and zero extended in other places? (I'm biased since OpenVMS wants sign-extended behavior)

[akhuang]

llvm/lib/Target/X86/X86AsmPrinter.cpp

138

I think I'll have to add some code in the frontend to avoid making these constant exprs for some or all of these addrspacecasts....

145

Yeah, that'd be better; I think the version in this patch is missing a bunch of logic as well.

llvm/include/llvm/CodeGen/AsmPrinter.h

public:
   /// requested, it will override the alignment request if required for
   /// correctness.
   void emitAlignment(Align Alignment, const GlobalObject *GV = nullptr) const;
 
   /// Lower the specified LLVM Constant to an MCExpr.
   virtual const MCExpr *lowerConstant(const Constant *CV);
 
   /// Print a general LLVM constant to the .s file.
-  void emitGlobalConstant(const DataLayout &DL, const Constant *CV);
+  virtual void emitGlobalConstant(const DataLayout &DL, const Constant *CV);
 
   /// Unnamed constant global variables solely contaning a pointer to
   /// another globals variable act like a global variable "proxy", or GOT
   /// equivalents, i.e., it's only used to hold the address of the latter. One
   /// optimization is to replace accesses to these proxies by using the GOT
   /// entry for the final global instead. Hence, we select GOT equivalent
   /// candidates among all the module global variables, avoid emitting them
   /// unnecessarily and finally replace references to them by pc relative

llvm/lib/Target/X86/X86AsmPrinter.h

public:
 
   void emitInstruction(const MachineInstr *MI) override;
 
   void emitBasicBlockEnd(const MachineBasicBlock &MBB) override {
     AsmPrinter::emitBasicBlockEnd(MBB);
     SMShadowTracker.emitShadowPadding(*OutStreamer, getSubtargetInfo());
   }
 
+  /// This is used to lower certain X86 addrspacecasts.
+  void emitGlobalConstant(const DataLayout &DL, const Constant *CV) override;
+
   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
                        const char *ExtraCode, raw_ostream &O) override;
   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
                              const char *ExtraCode, raw_ostream &O) override;
 
   bool doInitialization(Module &M) override {
     SMShadowTracker.reset(0);
     SM.reset();

llvm/lib/Target/X86/X86AsmPrinter.cpp

 //===-- X86AsmPrinter.cpp - Convert X86 LLVM code to AT&T assembly --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a printer that converts from our internal representation
 // of machine-dependent LLVM code to X86 machine code.
 //
 //===----------------------------------------------------------------------===//
 
+#include "X86.h"
 #include "X86AsmPrinter.h"
 #include "MCTargetDesc/X86ATTInstPrinter.h"
 #include "MCTargetDesc/X86BaseInfo.h"
 #include "MCTargetDesc/X86TargetStreamer.h"
 #include "TargetInfo/X86TargetInfo.h"
 #include "X86InstrInfo.h"
 #include "X86MachineFunctionInfo.h"
 #include "X86Subtarget.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"

 void X86AsmPrinter::emitFunctionBodyEnd() {
   if (EmitFPOData) {
     if (auto *XTS =
             static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
       XTS->emitFPOEndProc();
   }
 }
 
+void X86AsmPrinter::emitGlobalConstant(const DataLayout &DL, const Constant *CV) {
+  // Use this function to emit special addrspacecasts.
+  if (!CV) {
+    AsmPrinter::emitGlobalConstant(DL, CV);
+    return;
+  }
+
+  const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV);
+
+  if (!CE || CE->getOpcode() != Instruction::AddrSpaceCast) {
+    AsmPrinter::emitGlobalConstant(DL, CV);
+    return;
+  }
+
+  Constant *Op = CE->getOperand(0);
+  unsigned DstAS = CE->getType()->getPointerAddressSpace();
+  unsigned SrcAS = Op->getType()->getPointerAddressSpace();
+
+  if (TM.isNoopAddrSpaceCast(SrcAS, DstAS)) {
+    // Remove the addrspacecast.
+    AsmPrinter::emitGlobalConstant(DL, Op);
+    return;
+  }
+
+  const MCExpr *ME = AsmPrinter::lowerConstant(Op);
+  if ((SrcAS == 0 || SrcAS == X86AS::PTR32_UPTR) && DstAS == X86AS::PTR64) {
+    // For zero extension, emit a zero constant. This doesn't handle cases when
+    // sign extension is specified.
+    const MCConstantExpr *C = MCConstantExpr::create(0, OutStreamer->getContext());
+    OutStreamer->emitValue(ME, DL.getTypeAllocSize(Op->getType()));
+    OutStreamer->emitValue(C, DL.getTypeAllocSize(Op->getType()));
+  } else if (DstAS == X86AS::PTR32_SPTR || DstAS == X86AS::PTR32_UPTR) {
+    // For trunc, just remove the addrspacecast.
+    AsmPrinter::emitGlobalConstant(DL, Op);
+  } else {
+    // Otherwise fallthrough to general case.
+    AsmPrinter::emitGlobalConstant(DL, CV);
+  }
+}
+
 /// PrintSymbolOperand - Print a raw symbol reference operand.  This handles
 /// jump tables, constant pools, global address and external symbols, all of
 /// which print to a label with various suffixes for relocation types etc.
 void X86AsmPrinter::PrintSymbolOperand(const MachineOperand &MO,
                                        raw_ostream &O) {
   switch (MO.getType()) {
   default: llvm_unreachable("unknown symbol type!");
   case MachineOperand::MO_ConstantPoolIndex:

llvm/test/CodeGen/X86/mixed-ptr-sizes-i686.ll

 ; CHECK-O0-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-O0-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; CHECK-O0-NEXT:    movl %ecx, (%eax)
 ; CHECK-O0-NEXT:    retl
 entry:
   store i32 %i, i32 addrspace(272)* %s, align 8
   ret void
 }
+
+; Test addrspacecast in static initializers.
+@teststr = dso_local global [8 x i8] c"teststr\00", align 1
+@global64 = dso_local global i8 addrspace(272)* addrspacecast (i8* getelementptr inbounds ([8 x i8], [8 x i8]* @teststr, i32 0, i32 0) to i8 addrspace(272)*), align 8
+
+define dso_local i8 addrspace(272)* @test_global_zext() {
+; ALL-LABEL: test_global_zext:
+; ALL:       # %bb.0: # %entry
+; ALL-NEXT:    movl _global64, %eax
+; ALL-NEXT:    movl _global64+4, %edx
+entry:
+  %0 = load i8 addrspace(272)*, i8 addrspace(272)** @global64, align 8
+  ret i8 addrspace(272)* %0
+}

llvm/test/CodeGen/X86/mixed-ptr-sizes.ll

 ; ALL-LABEL: test_store_ptr64:
 ; ALL:       # %bb.0: # %entry
 ; ALL-NEXT:    movl %edx, (%rcx)
 ; ALL-NEXT:    retq
 entry:
   store i32 %i, i32 addrspace(272)* %s, align 8
   ret void
 }
+
+; Test addrspacecast in static initializers.
+@teststr = dso_local global [8 x i8] c"teststr\00", align 1
+@global32 = dso_local global i8 addrspace(270)* addrspacecast (i8* getelementptr inbounds ([8 x i8], [8 x i8]* @teststr, i32 0, i32 0) to i8 addrspace(270)*), align 8
+
+define dso_local i8 addrspace(270)* @test_global_trunc() {
+; ALL-LABEL: test_global_trunc:
+; ALL:       # %bb.0: # %entry
+; ALL-NEXT:    movl global32(%rip), %eax
+; ALL-NEXT:    retq
+entry:
+  %0 = load i8 addrspace(270)*, i8 addrspace(270)** @global32, align 4
+  ret i8 addrspace(270)* %0
+}