[WebAssembly] Don't override default implementation of isOffsetFoldingLegal. NFC.

[sbc100]

Summary

The default implementation does what want and is going to more
compatible with dynamic linking / -fPIC support that is planned.

In particular it prevents constant folder of global addresses when
isPositionIndependent() .

This is NFC because currently we only build wasm with
-relocation-model=static which in turn means that
the default isOffsetFoldingLegal always returns true today.

[dschuff]

Not sure I am parsing your commit message right. So we fold if DSO local, and not otherwise?

[sbc100]

Yes, this should have no effect unless we are compiling with -fPIC and have non-DSO-local symbols.

[sbc100]

In D54661#1303664, @dschuff wrote:

Not sure I am parsing your commit message right. So we fold if DSO local, and not otherwise?

Actually, even for DSO-local symbols we might not be able to do constant folding since we need to offset all accessed via get_global __memory_base.

[dschuff]

Yeah I think for PIC code all globals need to be relative.

If I understand isOffsetFoldingLegal, currently we have i32.load addr($pop) where the addr is a constant and the offset comes from the stack (e.g. could be the result of a gep but is often i32.const 0) and the addr is the folded address of the global.

If there's no individual interposition we could use something like this in cases where it would have been const 0 before:

get_global __memoryBase
i32.load addr($pop)

If there's a constant gep, it should actually be legal to fold that into the address too: i32.load addr+n($pop).
If there's a variable gep, it has to be added to the memory base, but the addr can still be a constant relative to the memory base. Does that mean isOffsetFoldingLegal is true then? Not sure, I'd want to look at the code a bit more and also at e.g. our address-offsets.ll test.

[sbc100]

• rebase

[sbc100]

• move to mono-repo

[sbc100]

-rebase

[sbc100]

This is needed for my PIC change: https://reviews.llvm.org/D54647

It seems to do exactly what we want. It avoids folding the constant into access of the global address itself, but it still can fold the constant into the follow load. e.g.: from that CL:

global.get $push0=, g@GOT
i32.load  $push1=, 40($pop0)

[sbc100]

@dschuff i updated the PR description and hopefully this a good to go now?

lib/Target/TargetMachine.cpp

bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
   // is ABI and relocation depended, it seems worth it to handle it
   // here.
   if (GV && isPositionIndependent() && GV->hasExternalWeakLinkage())
     return false;
 
   if (GV && !GV->hasDefaultVisibility())
     return true;
 
-  if (TT.isOSBinFormatMachO()) {
+  if (TT.isOSBinFormatMachO() || TT.isOSBinFormatWasm()) {
     if (RM == Reloc::Static)
       return true;
     return GV && GV->isStrongDefinitionForLinker();
   }
 
   assert(TT.isOSBinFormatELF());
   assert(RM != Reloc::DynamicNoPIC);
 

lib/Target/WebAssembly/WebAssemblyISelLowering.h

 private:
   /// Keep a pointer to the WebAssemblySubtarget around so that we can make the
   /// right decision when generating code for different targets.
   const WebAssemblySubtarget *Subtarget;
 
   AtomicExpansionKind shouldExpandAtomicRMWInIR(AtomicRMWInst *) const override;
   FastISel *createFastISel(FunctionLoweringInfo &FuncInfo,
                            const TargetLibraryInfo *LibInfo) const override;
-  bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
   MVT getScalarShiftAmountTy(const DataLayout &DL, EVT) const override;
   MachineBasicBlock *
   EmitInstrWithCustomInserter(MachineInstr &MI,
                               MachineBasicBlock *MBB) const override;
   const char *getTargetNodeName(unsigned Opcode) const override;
   std::pair<unsigned, const TargetRegisterClass *>
   getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
                                StringRef Constraint, MVT VT) const override;

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

WebAssemblyTargetLowering::shouldExpandAtomicRMWInIR(AtomicRMWInst *AI) const {
   return AtomicExpansionKind::CmpXChg;
 }
 
 FastISel *WebAssemblyTargetLowering::createFastISel(
     FunctionLoweringInfo &FuncInfo, const TargetLibraryInfo *LibInfo) const {
   return WebAssembly::createFastISel(FuncInfo, LibInfo);
 }
 
-bool WebAssemblyTargetLowering::isOffsetFoldingLegal(
-    const GlobalAddressSDNode * /*GA*/) const {
-  // All offsets can be folded.
-  return true;
-}
-
 MVT WebAssemblyTargetLowering::getScalarShiftAmountTy(const DataLayout & /*DL*/,
                                                       EVT VT) const {
   unsigned BitWidth = NextPowerOf2(VT.getSizeInBits() - 1);
   if (BitWidth > 1 && BitWidth < 8)
     BitWidth = 8;
 
   if (BitWidth > 64) {
     // The shift will be lowered to a libcall, and compiler-rt libcalls expect