[Wasm] Revert all relative pointer workarounds

kateinoigakukun · kateinoigakukun · commit 1242d93ec00d · 2022-03-24T08:41:32.000Z
diff --git a/include/swift/Basic/RelativePointer.h b/include/swift/Basic/RelativePointer.h
@@ -146,11 +146,6 @@ static inline uintptr_t applyRelativeOffset(BasePtrTy *basePtr, Offset offset) {
                 std::is_signed<Offset>::value,
                 "offset type should be signed integer");
 
-#ifdef __wasm__
-  // WebAssembly: hack: disable relative pointers
-  return (uintptr_t)(intptr_t)offset;
-#endif
-
   auto base = reinterpret_cast<uintptr_t>(basePtr);
   // We want to do wrapping arithmetic, but with a sign-extended
   // offset. To do this in C, we need to do signed promotion to get
@@ -169,13 +164,6 @@ static inline Offset measureRelativeOffset(A *referent, B *base) {
   static_assert(std::is_integral<Offset>::value &&
                 std::is_signed<Offset>::value,
                 "offset type should be signed integer");
-#ifdef __wasm__
-  // WebAssembly: hack: disable relative pointers
-  auto offset = (Offset)(uintptr_t)referent;
-  assert((intptr_t)offset == (intptr_t)(uintptr_t)referent
-         && "pointer too large to fit in offset type");
-  return offset;
-#endif
 
   auto distance = (uintptr_t)referent - (uintptr_t)base;
   // Truncate as unsigned, then wrap around to signed.
diff --git a/lib/IRGen/ConstantBuilder.h b/lib/IRGen/ConstantBuilder.h
@@ -91,11 +91,6 @@ class ConstantAggregateBuilderBase
 
   void addRelativeAddress(llvm::Constant *target) {
     assert(!isa<llvm::ConstantPointerNull>(target));
-    if (IGM().TargetInfo.OutputObjectFormat == llvm::Triple::Wasm) {
-      // WebAssembly: hack: doesn't support PCrel data relocations
-      add(llvm::ConstantExpr::getPtrToInt(target, IGM().RelativeAddressTy, false));
-      return;
-    }
     addRelativeOffset(IGM().RelativeAddressTy, target);
   }
 
@@ -104,21 +99,6 @@ class ConstantAggregateBuilderBase
   /// a "GOT-equivalent", i.e. a pointer to an external object; if so,
   /// set the low bit of the offset to indicate that this is true.
   void addRelativeAddress(ConstantReference reference) {
-    if (IGM().TargetInfo.OutputObjectFormat == llvm::Triple::Wasm) {
-      // WebAssembly: hack: doesn't support PCrel data relocations
-      // also, we should set the lowest bit, but I don't know how to do that
-      // there's no GOT on WebAssembly anyways though
-
-
-      llvm::Constant *offset = llvm::ConstantExpr::getPtrToInt(reference.getValue(), IGM().RelativeAddressTy, false);
-      // borrowed from addTaggedRelativeOffset
-      unsigned tag = unsigned(reference.isIndirect());
-      if (tag) {
-        offset = llvm::ConstantExpr::getAdd(offset, llvm::ConstantInt::get(IGM().RelativeAddressTy, tag));
-      }
-      add(offset);
-      return;
-    }
     addTaggedRelativeOffset(IGM().RelativeAddressTy,
                             reference.getValue(),
                             unsigned(reference.isIndirect()));
@@ -128,11 +108,6 @@ class ConstantAggregateBuilderBase
   /// The target must be a "GOT-equivalent", i.e. a pointer to an
   /// external object.
   void addIndirectRelativeAddress(ConstantReference reference) {
-    if (IGM().TargetInfo.OutputObjectFormat == llvm::Triple::Wasm) {
-      // WebAssembly: hack: doesn't support PCrel data relocations
-      add(llvm::ConstantExpr::getPtrToInt(reference.getValue(), IGM().RelativeAddressTy, false));
-      return;
-    }
     assert(reference.isIndirect());
     addRelativeOffset(IGM().RelativeAddressTy,
                       reference.getValue());
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
@@ -3738,11 +3738,6 @@ IRGenModule::emitDirectRelativeReference(llvm::Constant *target,
   // Convert the target to an integer.
   auto targetAddr = llvm::ConstantExpr::getPtrToInt(target, SizeTy);
 
-  // WebAssembly hack: WebAssembly doesn't support PC-relative references
-  if (TargetInfo.OutputObjectFormat == llvm::Triple::Wasm) {
-    return targetAddr;
-  }
-
   SmallVector<llvm::Constant*, 4> indices;
   indices.push_back(llvm::ConstantInt::get(Int32Ty, 0));
   for (unsigned baseIndex : baseIndices) {
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -5493,18 +5493,7 @@ GenericRequirementsMetadata irgen::addGenericRequirements(
           unsigned tag = unsigned(descriptorRef.isIndirect());
           if (protocol->isObjC())
             tag |= 0x02;
-          // WebAssembly: hack: Wasm doesn't support PC-relative offsets.
-          // also doesn't handle tag yet
-          if (IGM.TargetInfo.OutputObjectFormat == llvm::Triple::Wasm) {
-            llvm::Constant *offset = llvm::ConstantExpr::getPtrToInt(descriptorRef.getValue(), IGM.RelativeAddressTy, false);
-            // borrowed from addTaggedRelativeOffset
-            if (tag) {
-                offset = llvm::ConstantExpr::getAdd(offset, llvm::ConstantInt::get(IGM.RelativeAddressTy, tag));
-            }
-            B.add(offset);
-            return;
-          }
-          
+
           B.addTaggedRelativeOffset(IGM.RelativeAddressTy,
                                     descriptorRef.getValue(),
                                     tag);
diff --git a/lib/IRGen/IRGenFunction.cpp b/lib/IRGen/IRGenFunction.cpp
@@ -330,13 +330,6 @@ IRGenFunction::emitLoadOfRelativePointer(Address addr, bool isFar,
     value = Builder.CreateSExt(value, IGM.IntPtrTy);
   }
 
-  // FIXME: add absolute pointer mode for IRGen
-  if (IGM.TargetInfo.OutputObjectFormat == llvm::Triple::Wasm) {
-    auto *uncastPointer = Builder.CreateIntToPtr(value, IGM.Int8PtrTy);
-    auto uncastPointerAddress = Address(uncastPointer, IGM.getPointerAlignment());
-    auto pointer = Builder.CreateBitCast(uncastPointerAddress, expectedType);
-    return pointer.getAddress();
-  }
   auto *addrInt = Builder.CreatePtrToInt(addr.getAddress(), IGM.IntPtrTy);
   auto *uncastPointerInt = Builder.CreateAdd(addrInt, value);
   auto *uncastPointer = Builder.CreateIntToPtr(uncastPointerInt, IGM.Int8PtrTy);
diff --git a/lib/IRGen/MetadataRequest.cpp b/lib/IRGen/MetadataRequest.cpp
@@ -2775,18 +2775,14 @@ emitMetadataAccessByMangledName(IRGenFunction &IGF, CanType type,
                                                           IGM.SizeTy);
 
     llvm::Value *stringAddr;
-    if (IGM.TargetInfo.OutputObjectFormat == llvm::Triple::Wasm) {
-      stringAddr = subIGF.Builder.CreateIntToPtr(stringAddrOffset, IGM.Int8PtrTy);
-    } else {
-      auto stringAddrBase = subIGF.Builder.CreatePtrToInt(cache, IGM.SizeTy);
-      if (IGM.getModule()->getDataLayout().isBigEndian()) {
-        stringAddrBase = subIGF.Builder.CreateAdd(stringAddrBase,
-                                        llvm::ConstantInt::get(IGM.SizeTy, 4));
-      }
-      stringAddr = subIGF.Builder.CreateAdd(stringAddrBase,
-                                                stringAddrOffset);
-      stringAddr = subIGF.Builder.CreateIntToPtr(stringAddr, IGM.Int8PtrTy);
+    auto stringAddrBase = subIGF.Builder.CreatePtrToInt(cache, IGM.SizeTy);
+    if (IGM.getModule()->getDataLayout().isBigEndian()) {
+      stringAddrBase = subIGF.Builder.CreateAdd(stringAddrBase,
+                                      llvm::ConstantInt::get(IGM.SizeTy, 4));
     }
+    stringAddr = subIGF.Builder.CreateAdd(stringAddrBase,
+                                              stringAddrOffset);
+    stringAddr = subIGF.Builder.CreateIntToPtr(stringAddr, IGM.Int8PtrTy);
 
     llvm::CallInst *call;
     if (request.isStaticallyAbstract()) {
diff --git a/stdlib/public/core/KeyPath.swift b/stdlib/public/core/KeyPath.swift
@@ -2700,19 +2700,9 @@ internal protocol KeyPathPatternVisitor {
 
 internal func _resolveRelativeAddress(_ base: UnsafeRawPointer,
                                       _ offset: Int32) -> UnsafeRawPointer {
-  #if arch(wasm32)
-  // FIXME: If offset is 0, it means the pointer is null.
-  // For real relative pointer, it always calculates valid non-null address
-  // because the base address is always valid.
-  // But hacked absolute pointer can be null pointer.
-  // The return type doesn't allow nil, so return given base temporarily.
-  if offset == 0 { return base }
-  return UnsafeRawPointer(bitPattern: Int(offset)).unsafelyUnwrapped
-  #else
   // Sign-extend the offset to pointer width and add with wrap on overflow.
   return UnsafeRawPointer(bitPattern: Int(bitPattern: base) &+ Int(offset))
     .unsafelyUnwrapped
-  #endif
 }
 internal func _resolveRelativeIndirectableAddress(_ base: UnsafeRawPointer,
                                                   _ offset: Int32)
