Remove support for linear memory in the cheerp-genericjs target

clang/lib/CodeGen/CGException.cpp

@@ -877,6 +877,14 @@ llvm::BasicBlock *CodeGenFunction::EmitLandingPad() {
   LPadInst = Builder.CreateLandingPad(LPadTy, 0);
 
   llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0);
+  if(!CGM.getTarget().isByteAddressable()) {
+    if (CGM.getTarget().getTriple().isCheerpWasm()) {
+      LPadExn = Builder.CreateIntToPtr(LPadExn, Int8PtrTy);
+    } else {
+      llvm::Function *MakeReg = CGM.getIntrinsic(llvm::Intrinsic::cheerp_make_regular, {Int8PtrTy, Int8PtrTy});
+      LPadExn = Builder.CreateCall(MakeReg, {llvm::ConstantPointerNull::get(Int8PtrTy), LPadExn});
+    }
+  }
   Builder.CreateStore(LPadExn, getExceptionSlot());
   llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1);
   Builder.CreateStore(LPadSel, getEHSelectorSlot());
@@ -1575,6 +1583,14 @@ llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() {
   llvm::Value *Exn = nullptr;
   if (getLangOpts().CPlusPlus) {
     Exn = Builder.CreateExtractValue(LPadInst, 0);
+    if(!CGM.getTarget().isByteAddressable()) {
+      if (CGM.getTarget().getTriple().isCheerpWasm()) {
+        Exn = Builder.CreateIntToPtr(Exn, Int8PtrTy);
+      } else {
+        llvm::Function *MakeReg = CGM.getIntrinsic(llvm::Intrinsic::cheerp_make_regular, {Int8PtrTy, Int8PtrTy});
+        Exn = Builder.CreateCall(MakeReg, {llvm::ConstantPointerNull::get(Int8PtrTy), Exn});
+      }
+    }
   }
   llvm::CallInst *terminateCall =
       CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn);
@@ -1675,6 +1691,14 @@ llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) {
 
   llvm::Type *LPadType = GetLandingPadTy();
   llvm::Value *LPadVal = llvm::UndefValue::get(LPadType);
+  if (!CGM.getTarget().isByteAddressable()) {
+    if (CGM.getTarget().getTriple().isCheerpWasm()) {
+      Exn = Builder.CreatePtrToInt(Exn, Int32Ty);
+    } else {
+      llvm::Function *PtrOffset = CGM.getIntrinsic(llvm::Intrinsic::cheerp_pointer_offset, {Int8PtrTy});
+      Exn = Builder.CreateCall(PtrOffset, Exn);
+    }
+  }
   LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val");
   LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val");
   Builder.CreateResume(LPadVal);

clang/lib/CodeGen/CodeGenFunction.h

@@ -2016,9 +2016,10 @@ class CodeGenFunction : public CodeGenTypeCache {
     auto* Ret = llvm::StructType::getTypeByName(CGM.getLLVMContext(), "struct._ZN10__cxxabiv119__cheerp_landingpadE");
     if (Ret)
       return Ret;
-    llvm::Type* Tys[] { CGM.Int8PtrTy, CGM.Int32Ty};
+    llvm::Type* Tys[] { CGM.Int32Ty, CGM.Int32Ty};
 
-    return llvm::StructType::create(Tys, "struct._ZN10__cxxabiv119__cheerp_landingpadE", false, nullptr, false, true /*asmjs*/);
+    bool asmjs = getTarget().getTriple().isCheerpWasm();
+    return llvm::StructType::create(Tys, "struct._ZN10__cxxabiv119__cheerp_landingpadE", false, nullptr, false, asmjs);
   }
 
   /// Returns the contents of the function's exception object and selector

libcxxabi/src/cxa_cheerp.cpp

@@ -53,18 +53,18 @@ terminate() noexcept
 namespace [[cheerp::genericjs]] __cxxabiv1 {
 
 struct
+#ifdef __ASMJS__
 [[cheerp::wasm]]
+#endif
  __cheerp_landingpad
 {
-	void* val;
+	uintptr_t val;
 	int sel;
 
 	[[cheerp::genericjs]]
-	static void set_val(__cheerp_landingpad* lp, void* v) noexcept
+	void set_val(void* v) noexcept
 	{
-		int intval = __builtin_cheerp_pointer_offset(v);
-		__cheerp_landingpad** hack = reinterpret_cast<__cheerp_landingpad**>(lp);
-		*hack = reinterpret_cast<__cheerp_landingpad*>(intval);
+		val = __builtin_cheerp_pointer_offset(v);
 	}
 };
 
@@ -537,15 +537,15 @@ __gxx_personality_v0
 			}
 		}
 	}
-	__cheerp_landingpad lp{nullptr, 0};
+	__cheerp_landingpad lp{0, 0};
 	if(!native)
 	{
 		curNonNativeException = obj;
 		return lp;
 	}
 
 	Exception* ex = current_exception;
-	__cheerp_landingpad::set_val(&lp, ex);
+	lp.set_val(ex);
 
 	for(int i = start; i < start+n; i++)
 	{

llvm/include/llvm/ADT/Triple.h

@@ -786,7 +786,7 @@ class Triple {
 
   /// Tests wheter the target is cheerp-wasm
   bool isCheerpWasm() const {
-    return getArch() == Triple::cheerp && getObjectFormat() == Triple::Wasm;
+    return getArch() == Triple::cheerp && getEnvironment() == Triple::WebAssembly;
   }
 
   /// Tests whether the target supports the EHABI exception

llvm/include/llvm/Cheerp/GlobalDepsAnalyzer.h

@@ -119,23 +119,10 @@ class GlobalDepsAnalyzer
 	 */
 	bool needCreatePointerArray() const { return hasPointerArrays; }
 
-	/**
-	 * Determine if we need to compile the asm.js module
-	 */
-	bool needAsmJSCode() const { return hasAsmJSCode; }
-	/**
-	 * Determine if we need to compile the asm.js module
-	 */
-	bool needAsmJSMemory() const { return hasAsmJSMemory; }
 	/**
 	 * Determine if we need to compile the definition of CheerpException
 	 */
 	bool needCheerpException() const { return hasCheerpException; }
-
-	/**
-	 * Determine if linear memory malloc is ever used
-	 */
-	bool usesAsmJSMalloc() const { return hasAsmJSMalloc; }
 
 	bool usesAtomics() const { return hasAtomics; }
 
@@ -241,8 +228,10 @@ class GlobalDepsAnalyzer
 
 	static void replaceFunctionAliasWithAliasee(llvm::Module &module, llvm::StringRef name);
 
-	//Extend lifetime of function, visiting them and declaring external
-	void extendLifetime(llvm::Function* F);
+	//Extend lifetime of global, visiting them and declaring external
+	void extendLifetime(llvm::GlobalValue* G);
+	// Same but F might be null
+	void extendLifetimeIfPresent(llvm::GlobalValue* G);
 
 	//Determine whether an instruction is atomic.
 	bool isAtomicInstruction(const llvm::Instruction& I);
@@ -274,16 +263,11 @@ class GlobalDepsAnalyzer
 	bool hasCreateClosureUsers;
 	bool hasVAArgs;
 	bool hasPointerArrays;
-	bool hasAsmJSCode;
 	bool hasAtomics;
-	bool hasAsmJSMemory;
-	bool hasAsmJSMalloc;
 	bool hasCheerpException;
-	bool mayNeedAsmJSFree;
 
 	bool llcPass;
 	bool hasUndefinedSymbolErrors;
-	bool preserveFree;
 public:
 	bool forceTypedArrays;
 	bool needsBuiltin(BuiltinInstr::BUILTIN b)

llvm/include/llvm/Cheerp/Writer.h

@@ -12,6 +12,7 @@
 #ifndef _CHEERP_WRITER_H
 #define _CHEERP_WRITER_H
 
+#include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Cheerp/AllocaMerging.h"
 #include "llvm/Cheerp/BaseWriter.h"
@@ -182,6 +183,7 @@ class CheerpWriter final : public CheerpBaseWriter
 	llvm::ModuleAnalysisManager& MAM;
 	llvm::FunctionAnalysisManager& FAM;
 	llvm::DataLayout targetData;
+	bool isWasmTarget;
 	const llvm::Function* currentFun;
 	// function-local map of type_info* to typeid, for exception handling
 	llvm::DenseMap<llvm::Value*, int> typeIdMap;
@@ -617,6 +619,7 @@ class CheerpWriter final : public CheerpBaseWriter
 		MAM(MAM),
 		FAM(MAM.getResult<llvm::FunctionAnalysisManagerModuleProxy>(m).getManager()),
 		targetData(&m),
+		isWasmTarget(llvm::Triple(m.getTargetTriple()).isCheerpWasm()),
 		currentFun(NULL),
 		PA(PA),
 		registerize(registerize),

llvm/include/llvm/IR/IntrinsicsCheerp.td

@@ -61,6 +61,9 @@ def int_cheerp_pointer_offset : Intrinsic<[llvm_i32_ty],
 def int_cheerp_is_linear_heap : Intrinsic<[llvm_i1_ty],
                                 [llvm_anyptr_ty],
                                 [IntrNoMem]>;
+def int_cheerp_pointer_elem_size : Intrinsic<[llvm_i32_ty],
+                                [llvm_anyptr_ty],
+                                [IntrNoMem]>;
 
 // Closure creation for callbacks
 def int_cheerp_create_closure : Intrinsic<[llvm_anyptr_ty],

llvm/lib/CheerpUtils/AllocaLowering.cpp

@@ -172,7 +172,7 @@ bool AllocaLowering::runOnFunction(Function& F, DominatorTree& DT, cheerp::Globa
 	nbytes = (nbytes + 7) & -8;
 
 	Function *getStack, *setStack;
-	if (asmjs || !GDA.needAsmJSCode())
+	if (asmjs)
 	{
 		getStack = Intrinsic::getDeclaration(M, Intrinsic::stacksave);
 		setStack = Intrinsic::getDeclaration(M, Intrinsic::stackrestore);

llvm/lib/CheerpUtils/CallConstructors.cpp

@@ -98,8 +98,7 @@ PreservedAnalyses CallConstructorsPass::run(llvm::Module &M, llvm::ModuleAnalysi
 				}
 				else
 				{
-					Value* EnvA = Builder.CreateAlloca(EnvTy);
-					Env = Builder.CreateLoad(EnvTy, EnvA);
+					Env = Builder.CreateAlloca(Builder.getInt8Ty()->getPointerTo(0));
 					Builder.CreateStore(ConstantPointerNull::get(cast<PointerType>(EnvTy->getPointerElementType())), Env);
 				}