Remove legacy LL[Maybe]Align

kinke · kinke · commit 5d3ded9eeba3 · 2023-07-29T02:09:35.000+02:00
diff --git a/gen/abi/x86.cpp b/gen/abi/x86.cpp
@@ -266,7 +266,7 @@ struct X86TargetABI : TargetABI {
 #else
           // Keep alignment for LLVM 13+, to prevent invalid `movaps` etc.,
           // but limit to 4 (required according to runnable/ldc_cabi1.d).
-          auto align4 = LLAlign(4);
+          auto align4 = llvm::Align(4);
           if (arg->attrs.getAlignment().
 #if LDC_LLVM_VER >= 1500
               value_or
diff --git a/gen/coverage.cpp b/gen/coverage.cpp
@@ -44,16 +44,17 @@ void emitCoverageLinecountInc(const Loc &loc) {
     // Do an atomic increment, so this works when multiple threads are executed.
     gIR->ir->CreateAtomicRMW(llvm::AtomicRMWInst::Add, ptr, DtoConstUint(1),
 #if LDC_LLVM_VER >= 1300
-                             LLAlign(4),
+                             llvm::Align(4),
 #endif
                              llvm::AtomicOrdering::Monotonic);
     break;
   case opts::CoverageIncrement::nonatomic: {
     // Do a non-atomic increment, user is responsible for correct results with
     // multithreaded execution
-    llvm::LoadInst *load = gIR->ir->CreateAlignedLoad(i32Type, ptr, LLAlign(4));
+    llvm::LoadInst *load =
+        gIR->ir->CreateAlignedLoad(i32Type, ptr, llvm::Align(4));
     llvm::StoreInst *store = gIR->ir->CreateAlignedStore(
-        gIR->ir->CreateAdd(load, DtoConstUint(1)), ptr, LLAlign(4));
+        gIR->ir->CreateAdd(load, DtoConstUint(1)), ptr, llvm::Align(4));
     // add !nontemporal attribute, to inform the optimizer that caching is not
     // needed
     llvm::MDNode *node = llvm::MDNode::get(
@@ -66,7 +67,7 @@ void emitCoverageLinecountInc(const Loc &loc) {
     // Do a boolean set, avoiding a memory read (blocking) and threading issues
     // at the cost of not "counting"
     llvm::StoreInst *store =
-        gIR->ir->CreateAlignedStore(DtoConstUint(1), ptr, LLAlign(4));
+        gIR->ir->CreateAlignedStore(DtoConstUint(1), ptr, llvm::Align(4));
     // add !nontemporal attribute, to inform the optimizer that caching is not
     // needed
     llvm::MDNode *node = llvm::MDNode::get(
diff --git a/gen/dvalue.cpp b/gen/dvalue.cpp
@@ -180,7 +180,7 @@ DBitFieldLValue::DBitFieldLValue(Type *t, LLValue *ptr, BitFieldDeclaration *bf)
 DRValue *DBitFieldLValue::getRVal() {
   const auto sizeInBits = intType->getBitWidth();
   const auto ptr = DtoBitCast(val, getPtrToType(intType));
-  LLValue *v = gIR->ir->CreateAlignedLoad(intType, ptr, LLMaybeAlign(1));
+  LLValue *v = gIR->ir->CreateAlignedLoad(intType, ptr, llvm::MaybeAlign(1));
 
   if (bf->type->isunsigned()) {
     if (auto n = bf->bitOffset)
@@ -208,7 +208,8 @@ void DBitFieldLValue::store(LLValue *value) {
 
   const auto mask =
       llvm::APInt::getLowBitsSet(intType->getBitWidth(), bf->fieldWidth);
-  const auto oldVal = gIR->ir->CreateAlignedLoad(intType, ptr, LLMaybeAlign(1));
+  const auto oldVal =
+      gIR->ir->CreateAlignedLoad(intType, ptr, llvm::MaybeAlign(1));
   const auto maskedOldVal =
       gIR->ir->CreateAnd(oldVal, ~(mask << bf->bitOffset));
 
@@ -218,7 +219,7 @@ void DBitFieldLValue::store(LLValue *value) {
     bfVal = gIR->ir->CreateShl(bfVal, n);
 
   const auto newVal = gIR->ir->CreateOr(maskedOldVal, bfVal);
-  gIR->ir->CreateAlignedStore(newVal, ptr, LLMaybeAlign(1));
+  gIR->ir->CreateAlignedStore(newVal, ptr, llvm::MaybeAlign(1));
 }
 
 DDcomputeLValue::DDcomputeLValue(Type *t, llvm::Type * llt, LLValue *v) : DLValue(t, v) {
diff --git a/gen/irstate.cpp b/gen/irstate.cpp
@@ -147,7 +147,7 @@ IRState::setGlobalVarInitializer(LLGlobalVariable *&globalVar,
       module, initializer->getType(), globalVar->isConstant(),
       globalVar->getLinkage(), nullptr, "", nullptr,
       globalVar->getThreadLocalMode());
-  globalHelperVar->setAlignment(LLMaybeAlign(globalVar->getAlignment()));
+  globalHelperVar->setAlignment(llvm::MaybeAlign(globalVar->getAlignment()));
   globalHelperVar->setComdat(globalVar->getComdat());
   globalHelperVar->setDLLStorageClass(globalVar->getDLLStorageClass());
   globalHelperVar->setSection(globalVar->getSection());
diff --git a/gen/llvm.h b/gen/llvm.h
@@ -35,9 +35,6 @@ using llvm::APFloat;
 using llvm::APInt;
 using llvm::IRBuilder;
 
-#define LLAlign llvm::Align
-#define LLMaybeAlign llvm::MaybeAlign
-
 #define GET_INTRINSIC_DECL(_X)                                                 \
   (llvm::Intrinsic::getDeclaration(&gIR->module, llvm::Intrinsic::_X))
 
diff --git a/gen/llvmhelpers.cpp b/gen/llvmhelpers.cpp
@@ -191,7 +191,7 @@ llvm::AllocaInst *DtoArrayAlloca(Type *type, unsigned arraysize,
       lltype, gIR->module.getDataLayout().getAllocaAddrSpace(),
       DtoConstUint(arraysize), name, gIR->topallocapoint());
   if (auto alignment = DtoAlignment(type)) {
-    ai->setAlignment(LLAlign(alignment));
+    ai->setAlignment(llvm::Align(alignment));
   }
   return ai;
 }
@@ -202,7 +202,7 @@ llvm::AllocaInst *DtoRawAlloca(LLType *lltype, size_t alignment,
       lltype, gIR->module.getDataLayout().getAllocaAddrSpace(), name,
       gIR->topallocapoint());
   if (alignment) {
-    ai->setAlignment(LLAlign(alignment));
+    ai->setAlignment(llvm::Align(alignment));
   }
   return ai;
 }
diff --git a/gen/passes/SimplifyDRuntimeCalls.cpp b/gen/passes/SimplifyDRuntimeCalls.cpp
@@ -60,7 +60,7 @@ Value *LibCallOptimization::CastToCStr(Value *V, IRBuilder<> &B) {
 /// expects that the size has type 'intptr_t' and Dst/Src are pointers.
 Value *LibCallOptimization::EmitMemCpy(Value *Dst, Value *Src, Value *Len,
                                        unsigned Align, IRBuilder<> &B) {
-  auto A = LLMaybeAlign(Align);
+  auto A = llvm::MaybeAlign(Align);
   return B.CreateMemCpy(CastToCStr(Dst, B), A, CastToCStr(Src, B), A, Len,
                         false);
 }
diff --git a/gen/rttibuilder.cpp b/gen/rttibuilder.cpp
@@ -86,7 +86,7 @@ void RTTIBuilder::push_void_array(llvm::Constant *CI, Type *valtype,
   auto G = new LLGlobalVariable(gIR->module, CI->getType(), true, lwc.first, CI,
                                 initname.peekChars());
   setLinkage(lwc, G);
-  G->setAlignment(LLMaybeAlign(DtoAlignment(valtype)));
+  G->setAlignment(llvm::MaybeAlign(DtoAlignment(valtype)));
 
   push_void_array(getTypeAllocSize(CI->getType()), G);
 }
@@ -112,7 +112,7 @@ void RTTIBuilder::push_array(llvm::Constant *CI, uint64_t dim, Type *valtype,
   auto G = new LLGlobalVariable(gIR->module, CI->getType(), true, lwc.first, CI,
                                 initname.peekChars());
   setLinkage(lwc, G);
-  G->setAlignment(LLMaybeAlign(DtoAlignment(valtype)));
+  G->setAlignment(llvm::MaybeAlign(DtoAlignment(valtype)));
 
   push_array(dim, DtoBitCast(G, DtoType(valtype->pointerTo())));
 }
diff --git a/gen/tocall.cpp b/gen/tocall.cpp
@@ -415,7 +415,7 @@ bool DtoLowerMagicIntrinsic(IRState *p, FuncDeclaration *fndecl, CallExp *e,
     llvm::StoreInst *ret = p->ir->CreateStore(val, ptr);
     ret->setAtomic(llvm::AtomicOrdering(atomicOrdering));
     if (auto alignment = getTypeAllocSize(val->getType())) {
-      ret->setAlignment(LLAlign(alignment));
+      ret->setAlignment(llvm::Align(alignment));
     }
     return true;
   }
@@ -449,7 +449,7 @@ bool DtoLowerMagicIntrinsic(IRState *p, FuncDeclaration *fndecl, CallExp *e,
 
     llvm::LoadInst *load = p->ir->CreateLoad(loadedType, ptr);
     if (auto alignment = getTypeAllocSize(loadedType)) {
-      load->setAlignment(LLAlign(alignment));
+      load->setAlignment(llvm::Align(alignment));
     }
     load->setAtomic(llvm::AtomicOrdering(atomicOrdering));
     llvm::Value *val = load;
diff --git a/gen/toconstelem.cpp b/gen/toconstelem.cpp
@@ -443,7 +443,7 @@ class ToConstElemVisitor : public Visitor {
       auto globalVar = new llvm::GlobalVariable(
           p->module, DtoType(se->type), false,
           llvm::GlobalValue::InternalLinkage, nullptr, ".structliteral");
-      globalVar->setAlignment(LLMaybeAlign(DtoAlignment(se->type)));
+      globalVar->setAlignment(llvm::MaybeAlign(DtoAlignment(se->type)));
 
       p->setStructLiteralConstant(se, globalVar);
       llvm::Constant *constValue = toConstElem(se, p);
diff --git a/gen/toir.cpp b/gen/toir.cpp
@@ -164,7 +164,7 @@ static void write_struct_literal(Loc loc, LLValue *mem, StructDeclaration *sd,
 
       IF_LOG Logger::cout() << "merged IR value: " << *val << '\n';
       gIR->ir->CreateAlignedStore(val, DtoBitCast(ptr, getPtrToType(intType)),
-                                  LLMaybeAlign(1));
+                                  llvm::MaybeAlign(1));
       offset += group.sizeInBytes;
 
       i += group.bitFields.size() - 1; // skip the other bit fields of the group
diff --git a/gen/tollvm.cpp b/gen/tollvm.cpp
@@ -402,7 +402,8 @@ void DtoMemSet(LLValue *dst, LLValue *val, LLValue *nbytes, unsigned align) {
 
   dst = DtoBitCast(dst, VoidPtrTy);
 
-  gIR->ir->CreateMemSet(dst, val, nbytes, LLMaybeAlign(align), false /*isVolatile*/);
+  gIR->ir->CreateMemSet(dst, val, nbytes, llvm::MaybeAlign(align),
+                        false /*isVolatile*/);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -424,7 +425,7 @@ void DtoMemCpy(LLValue *dst, LLValue *src, LLValue *nbytes, unsigned align) {
   dst = DtoBitCast(dst, VoidPtrTy);
   src = DtoBitCast(src, VoidPtrTy);
 
-  auto A = LLMaybeAlign(align);
+  auto A = llvm::MaybeAlign(align);
   gIR->ir->CreateMemCpy(dst, A, src, A, nbytes, false /*isVolatile*/);
 }
 
@@ -532,7 +533,7 @@ LLValue *DtoLoad(DLValue *src, const char *name) {
 LLValue *DtoAlignedLoad(LLType *type, LLValue *src, const char *name) {
   llvm::LoadInst *ld = DtoLoadImpl(type, src, name);
   if (auto alignment = getABITypeAlign(ld->getType())) {
-    ld->setAlignment(LLAlign(alignment));
+    ld->setAlignment(llvm::Align(alignment));
   }
   return ld;
 }
@@ -570,7 +571,7 @@ void DtoAlignedStore(LLValue *src, LLValue *dst) {
          "Should store bools as i8 instead of i1.");
   llvm::StoreInst *st = gIR->ir->CreateStore(src, dst);
   if (auto alignment = getABITypeAlign(src->getType())) {
-    st->setAlignment(LLAlign(alignment));
+    st->setAlignment(llvm::Align(alignment));
   }
 }
 
diff --git a/ir/iraggr.cpp b/ir/iraggr.cpp
@@ -87,7 +87,7 @@ LLConstant *IrAggr::getInitSymbol(bool define) {
                                  irMangle, isConstant, false, useDLLImport());
     }
 
-    initGlobal->setAlignment(LLMaybeAlign(DtoAlignment(type)));
+    initGlobal->setAlignment(llvm::MaybeAlign(DtoAlignment(type)));
 
     init = initGlobal;
 
diff --git a/ir/irvar.cpp b/ir/irvar.cpp
@@ -114,7 +114,7 @@ void IrGlobal::declare() {
   // Set the alignment (it is important not to use type->alignsize because
   // VarDeclarations can have an align() attribute independent of the type
   // as well).
-  gvar->setAlignment(LLMaybeAlign(DtoAlignment(V)));
+  gvar->setAlignment(llvm::MaybeAlign(DtoAlignment(V)));
 
   applyVarDeclUDAs(V, gvar);
 
diff --git a/runtime/jit-rt/cpp-so/bind.cpp b/runtime/jit-rt/cpp-so/bind.cpp
@@ -18,9 +18,6 @@
 
 #include "valueparser.h"
 
-#define LLAlign llvm::Align
-#define LLMaybeAlign llvm::MaybeAlign
-
 namespace {
 enum { SmallParamsCount = 5 };
 
@@ -75,15 +72,15 @@ allocParam(llvm::IRBuilder<> &builder, llvm::Type &srcType,
     auto elemType = srcType.getPointerElementType();
     auto stackArg = builder.CreateAlloca(elemType);
     if (auto alignment = layout.getABITypeAlignment(elemType))
-      stackArg->setAlignment(LLAlign(alignment));
+      stackArg->setAlignment(llvm::Align(alignment));
     auto init =
         parseInitializer(layout, *elemType, param.data, errHandler, override);
     builder.CreateStore(init, stackArg);
     return stackArg;
   }
   auto stackArg = builder.CreateAlloca(&srcType);
   if (auto alignment = layout.getABITypeAlignment(&srcType))
-    stackArg->setAlignment(LLAlign(alignment));
+    stackArg->setAlignment(llvm::Align(alignment));
   auto init =
       parseInitializer(layout, srcType, param.data, errHandler, override);
   builder.CreateStore(init, stackArg);

Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ llvm::AllocaInst DtoArrayAlloca(Type type, unsigned arraysize,`
`191`	`191`	`lltype, gIR->module.getDataLayout().getAllocaAddrSpace(),`
`192`	`192`	`DtoConstUint(arraysize), name, gIR->topallocapoint());`
`193`	`193`	`if (auto alignment = DtoAlignment(type)) {`
`194`		`- ai->setAlignment(LLAlign(alignment));`
	`194`	`+ ai->setAlignment(llvm::Align(alignment));`
`195`	`195`	`}`
`196`	`196`	`return ai;`
`197`	`197`	`}`
`@@ -202,7 +202,7 @@ llvm::AllocaInst DtoRawAlloca(LLType lltype, size_t alignment,`
`202`	`202`	`lltype, gIR->module.getDataLayout().getAllocaAddrSpace(), name,`
`203`	`203`	`gIR->topallocapoint());`
`204`	`204`	`if (alignment) {`
`205`		`- ai->setAlignment(LLAlign(alignment));`
	`205`	`+ ai->setAlignment(llvm::Align(alignment));`
`206`	`206`	`}`
`207`	`207`	`return ai;`
`208`	`208`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ Value LibCallOptimization::CastToCStr(Value V, IRBuilder<> &B) {`
`60`	`60`	`/// expects that the size has type 'intptr_t' and Dst/Src are pointers.`
`61`	`61`	`Value LibCallOptimization::EmitMemCpy(Value Dst, Value Src, Value Len,`
`62`	`62`	`unsigned Align, IRBuilder<> &B) {`
`63`		`- auto A = LLMaybeAlign(Align);`
	`63`	`+ auto A = llvm::MaybeAlign(Align);`
`64`	`64`	`return B.CreateMemCpy(CastToCStr(Dst, B), A, CastToCStr(Src, B), A, Len,`
`65`	`65`	`false);`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -415,7 +415,7 @@ bool DtoLowerMagicIntrinsic(IRState p, FuncDeclaration fndecl, CallExp *e,`
`415`	`415`	`llvm::StoreInst *ret = p->ir->CreateStore(val, ptr);`
`416`	`416`	`ret->setAtomic(llvm::AtomicOrdering(atomicOrdering));`
`417`	`417`	`if (auto alignment = getTypeAllocSize(val->getType())) {`
`418`		`- ret->setAlignment(LLAlign(alignment));`
	`418`	`+ ret->setAlignment(llvm::Align(alignment));`
`419`	`419`	`}`
`420`	`420`	`return true;`
`421`	`421`	`}`
`@@ -449,7 +449,7 @@ bool DtoLowerMagicIntrinsic(IRState p, FuncDeclaration fndecl, CallExp *e,`
`449`	`449`
`450`	`450`	`llvm::LoadInst *load = p->ir->CreateLoad(loadedType, ptr);`
`451`	`451`	`if (auto alignment = getTypeAllocSize(loadedType)) {`
`452`		`- load->setAlignment(LLAlign(alignment));`
	`452`	`+ load->setAlignment(llvm::Align(alignment));`
`453`	`453`	`}`
`454`	`454`	`load->setAtomic(llvm::AtomicOrdering(atomicOrdering));`
`455`	`455`	`llvm::Value *val = load;`