mirrors/ldc
1
0
Fork 0
mirror of https://github.com/ldc-developers/ldc.git synced 2025-05-02 16:11:08 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove legacy LL[Maybe]Align

Browse source
This commit is contained in:
Martin Kinkelin 2023-07-29 01:58:14 +02:00
parent f6702cfbf5
commit 5d3ded9eeb
15 changed files with 29 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

2
gen/abi/x86.cpp
View file

@ -266,7 +266,7 @@ struct X86TargetABI : TargetABI {
#else #else
// Keep alignment for LLVM 13+, to prevent invalid `movaps` etc., // Keep alignment for LLVM 13+, to prevent invalid `movaps` etc.,
// but limit to 4 (required according to runnable/ldc_cabi1.d). // 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 (arg->attrs.getAlignment().
#if LDC_LLVM_VER >= 1500 #if LDC_LLVM_VER >= 1500
value_or value_or

9
gen/coverage.cpp
View file

@ -44,16 +44,17 @@ void emitCoverageLinecountInc(const Loc &loc) {
// Do an atomic increment, so this works when multiple threads are executed. // Do an atomic increment, so this works when multiple threads are executed.
gIR->ir->CreateAtomicRMW(llvm::AtomicRMWInst::Add, ptr, DtoConstUint(1), gIR->ir->CreateAtomicRMW(llvm::AtomicRMWInst::Add, ptr, DtoConstUint(1),
#if LDC_LLVM_VER >= 1300 #if LDC_LLVM_VER >= 1300
LLAlign(4), llvm::Align(4),
#endif #endif
llvm::AtomicOrdering::Monotonic); llvm::AtomicOrdering::Monotonic);
break; break;
case opts::CoverageIncrement::nonatomic: { case opts::CoverageIncrement::nonatomic: {
// Do a non-atomic increment, user is responsible for correct results with // Do a non-atomic increment, user is responsible for correct results with
// multithreaded execution // 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( 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 // add !nontemporal attribute, to inform the optimizer that caching is not
// needed // needed
llvm::MDNode *node = llvm::MDNode::get( 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 // Do a boolean set, avoiding a memory read (blocking) and threading issues
// at the cost of not "counting" // at the cost of not "counting"
llvm::StoreInst *store = 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 // add !nontemporal attribute, to inform the optimizer that caching is not
// needed // needed
llvm::MDNode *node = llvm::MDNode::get( llvm::MDNode *node = llvm::MDNode::get(

7
gen/dvalue.cpp
View file

@ -180,7 +180,7 @@ DBitFieldLValue::DBitFieldLValue(Type *t, LLValue *ptr, BitFieldDeclaration *bf)
DRValue *DBitFieldLValue::getRVal() { DRValue *DBitFieldLValue::getRVal() {
const auto sizeInBits = intType->getBitWidth(); const auto sizeInBits = intType->getBitWidth();
const auto ptr = DtoBitCast(val, getPtrToType(intType)); 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 (bf->type->isunsigned()) {
if (auto n = bf->bitOffset) if (auto n = bf->bitOffset)
@ -208,7 +208,8 @@ void DBitFieldLValue::store(LLValue *value) {
const auto mask = const auto mask =
llvm::APInt::getLowBitsSet(intType->getBitWidth(), bf->fieldWidth); 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 = const auto maskedOldVal =
gIR->ir->CreateAnd(oldVal, ~(mask << bf->bitOffset)); gIR->ir->CreateAnd(oldVal, ~(mask << bf->bitOffset));
@ -218,7 +219,7 @@ void DBitFieldLValue::store(LLValue *value) {
bfVal = gIR->ir->CreateShl(bfVal, n); bfVal = gIR->ir->CreateShl(bfVal, n);
const auto newVal = gIR->ir->CreateOr(maskedOldVal, bfVal); 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) { DDcomputeLValue::DDcomputeLValue(Type *t, llvm::Type * llt, LLValue *v) : DLValue(t, v) {

2
gen/irstate.cpp
View file

@ -147,7 +147,7 @@ IRState::setGlobalVarInitializer(LLGlobalVariable *&globalVar,
module, initializer->getType(), globalVar->isConstant(), module, initializer->getType(), globalVar->isConstant(),
globalVar->getLinkage(), nullptr, "", nullptr, globalVar->getLinkage(), nullptr, "", nullptr,
globalVar->getThreadLocalMode()); globalVar->getThreadLocalMode());
globalHelperVar->setAlignment(LLMaybeAlign(globalVar->getAlignment())); globalHelperVar->setAlignment(llvm::MaybeAlign(globalVar->getAlignment()));
globalHelperVar->setComdat(globalVar->getComdat()); globalHelperVar->setComdat(globalVar->getComdat());
globalHelperVar->setDLLStorageClass(globalVar->getDLLStorageClass()); globalHelperVar->setDLLStorageClass(globalVar->getDLLStorageClass());
globalHelperVar->setSection(globalVar->getSection()); globalHelperVar->setSection(globalVar->getSection());

3
gen/llvm.h
View file

@ -35,9 +35,6 @@ using llvm::APFloat;
using llvm::APInt; using llvm::APInt;
using llvm::IRBuilder; using llvm::IRBuilder;
#define LLAlign llvm::Align
#define LLMaybeAlign llvm::MaybeAlign
#define GET_INTRINSIC_DECL(_X) \ #define GET_INTRINSIC_DECL(_X) \
(llvm::Intrinsic::getDeclaration(&gIR->module, llvm::Intrinsic::_X)) (llvm::Intrinsic::getDeclaration(&gIR->module, llvm::Intrinsic::_X))

4
gen/llvmhelpers.cpp
View file

@ -191,7 +191,7 @@ llvm::AllocaInst *DtoArrayAlloca(Type *type, unsigned arraysize,
lltype, gIR->module.getDataLayout().getAllocaAddrSpace(), lltype, gIR->module.getDataLayout().getAllocaAddrSpace(),
DtoConstUint(arraysize), name, gIR->topallocapoint()); DtoConstUint(arraysize), name, gIR->topallocapoint());
if (auto alignment = DtoAlignment(type)) { if (auto alignment = DtoAlignment(type)) {
ai->setAlignment(LLAlign(alignment)); ai->setAlignment(llvm::Align(alignment));
} }
return ai; return ai;
} }
@ -202,7 +202,7 @@ llvm::AllocaInst *DtoRawAlloca(LLType *lltype, size_t alignment,
lltype, gIR->module.getDataLayout().getAllocaAddrSpace(), name, lltype, gIR->module.getDataLayout().getAllocaAddrSpace(), name,
gIR->topallocapoint()); gIR->topallocapoint());
if (alignment) { if (alignment) {
ai->setAlignment(LLAlign(alignment)); ai->setAlignment(llvm::Align(alignment));
} }
return ai; return ai;
} }

2
gen/passes/SimplifyDRuntimeCalls.cpp
View file

@ -60,7 +60,7 @@ Value *LibCallOptimization::CastToCStr(Value *V, IRBuilder<> &B) {
/// expects that the size has type 'intptr_t' and Dst/Src are pointers. /// expects that the size has type 'intptr_t' and Dst/Src are pointers.
Value *LibCallOptimization::EmitMemCpy(Value *Dst, Value *Src, Value *Len, Value *LibCallOptimization::EmitMemCpy(Value *Dst, Value *Src, Value *Len,
unsigned Align, IRBuilder<> &B) { 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, return B.CreateMemCpy(CastToCStr(Dst, B), A, CastToCStr(Src, B), A, Len,
false); false);
} }

4
gen/rttibuilder.cpp
View file

@ -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, auto G = new LLGlobalVariable(gIR->module, CI->getType(), true, lwc.first, CI,
initname.peekChars()); initname.peekChars());
setLinkage(lwc, G); setLinkage(lwc, G);
G->setAlignment(LLMaybeAlign(DtoAlignment(valtype))); G->setAlignment(llvm::MaybeAlign(DtoAlignment(valtype)));
push_void_array(getTypeAllocSize(CI->getType()), G); 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, auto G = new LLGlobalVariable(gIR->module, CI->getType(), true, lwc.first, CI,
initname.peekChars()); initname.peekChars());
setLinkage(lwc, G); setLinkage(lwc, G);
G->setAlignment(LLMaybeAlign(DtoAlignment(valtype))); G->setAlignment(llvm::MaybeAlign(DtoAlignment(valtype)));
push_array(dim, DtoBitCast(G, DtoType(valtype->pointerTo()))); push_array(dim, DtoBitCast(G, DtoType(valtype->pointerTo())));
} }

4
gen/tocall.cpp
View file

@ -415,7 +415,7 @@ bool DtoLowerMagicIntrinsic(IRState *p, FuncDeclaration *fndecl, CallExp *e,
llvm::StoreInst *ret = p->ir->CreateStore(val, ptr); llvm::StoreInst *ret = p->ir->CreateStore(val, ptr);
ret->setAtomic(llvm::AtomicOrdering(atomicOrdering)); ret->setAtomic(llvm::AtomicOrdering(atomicOrdering));
if (auto alignment = getTypeAllocSize(val->getType())) { if (auto alignment = getTypeAllocSize(val->getType())) {
ret->setAlignment(LLAlign(alignment)); ret->setAlignment(llvm::Align(alignment));
} }
return true; return true;
} }
@ -449,7 +449,7 @@ bool DtoLowerMagicIntrinsic(IRState *p, FuncDeclaration *fndecl, CallExp *e,
llvm::LoadInst *load = p->ir->CreateLoad(loadedType, ptr); llvm::LoadInst *load = p->ir->CreateLoad(loadedType, ptr);
if (auto alignment = getTypeAllocSize(loadedType)) { if (auto alignment = getTypeAllocSize(loadedType)) {
load->setAlignment(LLAlign(alignment)); load->setAlignment(llvm::Align(alignment));
} }
load->setAtomic(llvm::AtomicOrdering(atomicOrdering)); load->setAtomic(llvm::AtomicOrdering(atomicOrdering));
llvm::Value *val = load; llvm::Value *val = load;

2
gen/toconstelem.cpp
View file

@ -443,7 +443,7 @@ public:
auto globalVar = new llvm::GlobalVariable( auto globalVar = new llvm::GlobalVariable(
p->module, DtoType(se->type), false, p->module, DtoType(se->type), false,
llvm::GlobalValue::InternalLinkage, nullptr, ".structliteral"); llvm::GlobalValue::InternalLinkage, nullptr, ".structliteral");
globalVar->setAlignment(LLMaybeAlign(DtoAlignment(se->type))); globalVar->setAlignment(llvm::MaybeAlign(DtoAlignment(se->type)));
p->setStructLiteralConstant(se, globalVar); p->setStructLiteralConstant(se, globalVar);
llvm::Constant *constValue = toConstElem(se, p); llvm::Constant *constValue = toConstElem(se, p);

2
gen/toir.cpp
View file

@ -164,7 +164,7 @@ static void write_struct_literal(Loc loc, LLValue *mem, StructDeclaration *sd,
IF_LOG Logger::cout() << "merged IR value: " << *val << '\n'; IF_LOG Logger::cout() << "merged IR value: " << *val << '\n';
gIR->ir->CreateAlignedStore(val, DtoBitCast(ptr, getPtrToType(intType)), gIR->ir->CreateAlignedStore(val, DtoBitCast(ptr, getPtrToType(intType)),
LLMaybeAlign(1)); llvm::MaybeAlign(1));
offset += group.sizeInBytes; offset += group.sizeInBytes;
i += group.bitFields.size() - 1; // skip the other bit fields of the group i += group.bitFields.size() - 1; // skip the other bit fields of the group

9
gen/tollvm.cpp
View file

@ -402,7 +402,8 @@ void DtoMemSet(LLValue *dst, LLValue *val, LLValue *nbytes, unsigned align) {
dst = DtoBitCast(dst, VoidPtrTy); 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); dst = DtoBitCast(dst, VoidPtrTy);
src = DtoBitCast(src, VoidPtrTy); src = DtoBitCast(src, VoidPtrTy);
auto A = LLMaybeAlign(align); auto A = llvm::MaybeAlign(align);
gIR->ir->CreateMemCpy(dst, A, src, A, nbytes, false /*isVolatile*/); 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) { LLValue *DtoAlignedLoad(LLType *type, LLValue *src, const char *name) {
llvm::LoadInst *ld = DtoLoadImpl(type, src, name); llvm::LoadInst *ld = DtoLoadImpl(type, src, name);
if (auto alignment = getABITypeAlign(ld->getType())) { if (auto alignment = getABITypeAlign(ld->getType())) {
ld->setAlignment(LLAlign(alignment)); ld->setAlignment(llvm::Align(alignment));
} }
return ld; return ld;
} }
@ -570,7 +571,7 @@ void DtoAlignedStore(LLValue *src, LLValue *dst) {
"Should store bools as i8 instead of i1."); "Should store bools as i8 instead of i1.");
llvm::StoreInst *st = gIR->ir->CreateStore(src, dst); llvm::StoreInst *st = gIR->ir->CreateStore(src, dst);
if (auto alignment = getABITypeAlign(src->getType())) { if (auto alignment = getABITypeAlign(src->getType())) {
st->setAlignment(LLAlign(alignment)); st->setAlignment(llvm::Align(alignment));
} }
} }

2
ir/iraggr.cpp
View file

@ -87,7 +87,7 @@ LLConstant *IrAggr::getInitSymbol(bool define) {
irMangle, isConstant, false, useDLLImport()); irMangle, isConstant, false, useDLLImport());
} }
initGlobal->setAlignment(LLMaybeAlign(DtoAlignment(type))); initGlobal->setAlignment(llvm::MaybeAlign(DtoAlignment(type)));
init = initGlobal; init = initGlobal;

2
ir/irvar.cpp
View file

@ -114,7 +114,7 @@ void IrGlobal::declare() {
// Set the alignment (it is important not to use type->alignsize because // Set the alignment (it is important not to use type->alignsize because
// VarDeclarations can have an align() attribute independent of the type // VarDeclarations can have an align() attribute independent of the type
// as well). // as well).
gvar->setAlignment(LLMaybeAlign(DtoAlignment(V))); gvar->setAlignment(llvm::MaybeAlign(DtoAlignment(V)));
applyVarDeclUDAs(V, gvar); applyVarDeclUDAs(V, gvar);

7
runtime/jit-rt/cpp-so/bind.cpp
View file

@ -18,9 +18,6 @@
#include "valueparser.h" #include "valueparser.h"
#define LLAlign llvm::Align
#define LLMaybeAlign llvm::MaybeAlign
namespace { namespace {
enum { SmallParamsCount = 5 }; enum { SmallParamsCount = 5 };
@ -75,7 +72,7 @@ allocParam(llvm::IRBuilder<> &builder, llvm::Type &srcType,
auto elemType = srcType.getPointerElementType(); auto elemType = srcType.getPointerElementType();
auto stackArg = builder.CreateAlloca(elemType); auto stackArg = builder.CreateAlloca(elemType);
if (auto alignment = layout.getABITypeAlignment(elemType)) if (auto alignment = layout.getABITypeAlignment(elemType))
stackArg->setAlignment(LLAlign(alignment)); stackArg->setAlignment(llvm::Align(alignment));
auto init = auto init =
parseInitializer(layout, *elemType, param.data, errHandler, override); parseInitializer(layout, *elemType, param.data, errHandler, override);
builder.CreateStore(init, stackArg); builder.CreateStore(init, stackArg);
@ -83,7 +80,7 @@ allocParam(llvm::IRBuilder<> &builder, llvm::Type &srcType,
} }
auto stackArg = builder.CreateAlloca(&srcType); auto stackArg = builder.CreateAlloca(&srcType);
if (auto alignment = layout.getABITypeAlignment(&srcType)) if (auto alignment = layout.getABITypeAlignment(&srcType))
stackArg->setAlignment(LLAlign(alignment)); stackArg->setAlignment(llvm::Align(alignment));
auto init = auto init =
parseInitializer(layout, srcType, param.data, errHandler, override); parseInitializer(layout, srcType, param.data, errHandler, override);
builder.CreateStore(init, stackArg); builder.CreateStore(init, stackArg);