mirrors/ldc
1
0
Fork 0
mirror of https://github.com/ldc-developers/ldc.git synced 2025-04-29 06:30:39 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Adapt to TY enum class

Browse source
This commit is contained in:
Martin Kinkelin 2021-09-06 17:59:53 +02:00
parent 9dabd0ba16
commit 369cfd13ce
42 changed files with 512 additions and 494 deletions
Download patch file Download diff file Expand all files Collapse all files

2
gen/aa.cpp
View file

@ -27,7 +27,7 @@
// returns the keytype typeinfo
static LLConstant *to_keyti(const Loc &loc, DValue *aa, LLType *targetType) {
// keyti param
assert(aa->type->toBasetype()->ty == Taarray);
assert(aa->type->toBasetype()->ty == TY::Taarray);
TypeAArray *aatype = static_cast<TypeAArray *>(aa->type->toBasetype());
LLConstant *ti = DtoTypeInfoOf(loc, aatype->index, /*base=*/false);
return DtoBitCast(ti, targetType);

4
gen/abi-aarch64.cpp
View file

@ -60,7 +60,7 @@ public:
}
Type *rt = tf->next->toBasetype();
if (rt->ty == Tstruct || rt->ty == Tsarray) {
if (rt->ty == TY::Tstruct || rt->ty == TY::Tsarray) {
auto argTypes = getArgTypes(rt);
return !argTypes // FIXME: get rid of sret workaround for 0-sized return
// values (static arrays with 0 elements)
@ -75,7 +75,7 @@ public:
bool preferPassByRef(Type *t) override {
t = t->toBasetype();
if (!(t->ty == Tstruct || t->ty == Tsarray))
if (!(t->ty == TY::Tstruct || t->ty == TY::Tsarray))
return false;
auto argTypes = getArgTypes(t);

12
gen/abi-arm.cpp
View file

@ -38,8 +38,8 @@ struct ArmTargetABI : TargetABI {
if (!isPOD(rt))
return true;
return rt->ty == Tsarray ||
(rt->ty == Tstruct && rt->size() > 4 &&
return rt->ty == TY::Tsarray ||
(rt->ty == TY::Tstruct && rt->size() > 4 &&
(gTargetMachine->Options.FloatABIType == llvm::FloatABI::Soft ||
!isHFVA(rt, hfvaToArray.maxElements)));
}
@ -50,7 +50,7 @@ struct ArmTargetABI : TargetABI {
// converts back to non-byval. Without this special handling the
// optimzer generates bad code (e.g. std.random unittest crash).
t = t->toBasetype();
return ((t->ty == Tsarray || t->ty == Tstruct) && t->size() > 64);
return ((t->ty == TY::Tsarray || t->ty == TY::Tstruct) && t->size() > 64);
// Note: byval can have a codegen problem with -O1 and higher.
// What happens is that load instructions are being incorrectly
@ -72,7 +72,7 @@ struct ArmTargetABI : TargetABI {
void rewriteFunctionType(IrFuncTy &fty) override {
Type *retTy = fty.ret->type->toBasetype();
if (!fty.ret->byref && retTy->ty == Tstruct) {
if (!fty.ret->byref && retTy->ty == TY::Tstruct) {
// Rewrite HFAs only because union HFAs are turned into IR types that are
// non-HFA and messes up register selection
if (isHFVA(retTy, hfvaToArray.maxElements, &fty.ret->ltype)) {
@ -99,8 +99,8 @@ struct ArmTargetABI : TargetABI {
// TODO: want to also rewrite Tsarray as i32 arrays, but sometimes
// llvm selects an aligned ldrd instruction even though the ptr is
// unaligned (e.g. walking through members of array char[5][]).
// if (ty->ty == Tstruct || ty->ty == Tsarray)
if (ty->ty == Tstruct) {
// if (ty->ty == TY::Tstruct || ty->ty == TY::Tsarray)
if (ty->ty == TY::Tstruct) {
// Rewrite HFAs only because union HFAs are turned into IR types that are
// non-HFA and messes up register selection
if (isHFVA(ty, hfvaToArray.maxElements, &arg.ltype)) {

4
gen/abi-mips64.cpp
View file

@ -39,12 +39,12 @@ struct MIPS64TargetABI : TargetABI {
// because otherwise LLVM tries to actually return the array in a number
// of physical registers, which leads, depending on the target, to
// either horrendous codegen or backend crashes.
return (rt->ty == Tstruct || rt->ty == Tsarray);
return (rt->ty == TY::Tstruct || rt->ty == TY::Tsarray);
}
bool passByVal(TypeFunction *, Type *t) override {
TY ty = t->toBasetype()->ty;
return ty == Tstruct || ty == Tsarray;
return ty == TY::Tstruct || ty == TY::Tsarray;
}
void rewriteFunctionType(IrFuncTy &fty) override {

4
gen/abi-nvptx.cpp
View file

@ -26,7 +26,7 @@ struct NVPTXTargetABI : TargetABI {
}
bool passByVal(TypeFunction *, Type *t) override {
t = t->toBasetype();
return ((t->ty == Tsarray || t->ty == Tstruct) && t->size() > 64);
return ((t->ty == TY::Tsarray || t->ty == TY::Tstruct) && t->size() > 64);
}
bool reverseExplicitParams(TypeFunction *) override { return false; }
void rewriteFunctionType(IrFuncTy &fty) override {
@ -41,7 +41,7 @@ struct NVPTXTargetABI : TargetABI {
void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {
Type *ty = arg.type->toBasetype();
llvm::Optional<DcomputePointer> ptr;
if (ty->ty == Tstruct &&
if (ty->ty == TY::Tstruct &&
(ptr = toDcomputePointer(static_cast<TypeStruct *>(ty)->sym))) {
pointerRewite.applyTo(arg);
}

6
gen/abi-ppc.cpp
View file

@ -46,7 +46,7 @@ struct PPCTargetABI : TargetABI {
// returned in r3/r4 (ppc) or in r3 (ppc64). Looking at the IR
// generated by clang this seems not to be implemented. Regardless
// of size, the aggregate is always returned as sret.
return rt->ty == Tsarray || rt->ty == Tstruct;
return rt->ty == TY::Tsarray || rt->ty == TY::Tstruct;
}
bool passByVal(TypeFunction *, Type *t) override {
@ -54,7 +54,7 @@ struct PPCTargetABI : TargetABI {
// On ppc64, they are always passed by value. However, clang
// used byval for type > 64 bytes.
t = t->toBasetype();
return (t->ty == Tsarray || t->ty == Tstruct) &&
return (t->ty == TY::Tsarray || t->ty == TY::Tstruct) &&
(!Is64Bit || t->size() > 64);
}
@ -75,7 +75,7 @@ struct PPCTargetABI : TargetABI {
void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {
Type *ty = arg.type->toBasetype();
if (ty->ty == Tstruct || ty->ty == Tsarray) {
if (ty->ty == TY::Tstruct || ty->ty == TY::Tsarray) {
if (canRewriteAsInt(ty, Is64Bit)) {
integerRewrite.applyTo(arg);
} else {

8
gen/abi-ppc64le.cpp
View file

@ -43,8 +43,8 @@ struct PPC64LETargetABI : TargetABI {
bool passByVal(TypeFunction *, Type *t) override {
t = t->toBasetype();
return t->ty == Tsarray || (t->ty == Tstruct && t->size() > 16 &&
!isHFVA(t, hfvaToArray.maxElements));
return t->ty == TY::Tsarray || (t->ty == TY::Tstruct && t->size() > 16 &&
!isHFVA(t, hfvaToArray.maxElements));
}
void rewriteFunctionType(IrFuncTy &fty) override {
@ -63,8 +63,8 @@ struct PPC64LETargetABI : TargetABI {
void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {
Type *ty = arg.type->toBasetype();
if (ty->ty == Tstruct || ty->ty == Tsarray) {
if (ty->ty == Tstruct &&
if (ty->ty == TY::Tstruct || ty->ty == TY::Tsarray) {
if (ty->ty == TY::Tstruct &&
isHFVA(ty, hfvaToArray.maxElements, &arg.ltype)) {
hfvaToArray.applyTo(arg, arg.ltype);
} else if (canRewriteAsInt(ty, true)) {

4
gen/abi-spirv.cpp
View file

@ -26,7 +26,7 @@ struct SPIRVTargetABI : TargetABI {
}
bool passByVal(TypeFunction *, Type *t) override {
t = t->toBasetype();
return ((t->ty == Tsarray || t->ty == Tstruct) && t->size() > 64);
return ((t->ty == TY::Tsarray || t->ty == TY::Tstruct) && t->size() > 64);
}
bool reverseExplicitParams(TypeFunction *) override { return false; }
void rewriteFunctionType(IrFuncTy &fty) override {
@ -41,7 +41,7 @@ struct SPIRVTargetABI : TargetABI {
void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {
Type *ty = arg.type->toBasetype();
llvm::Optional<DcomputePointer> ptr;
if (ty->ty == Tstruct &&
if (ty->ty == TY::Tstruct &&
(ptr = toDcomputePointer(static_cast<TypeStruct *>(ty)->sym))) {
pointerRewite.applyTo(arg);
}

11
gen/abi-win64.cpp
View file

@ -39,7 +39,7 @@ private:
bool isX87(Type *t) const {
return !isMSVC // 64-bit reals for MSVC targets
&& (t->ty == Tfloat80 || t->ty == Timaginary80);
&& (t->ty == TY::Tfloat80 || t->ty == TY::Timaginary80);
}
bool passPointerToHiddenCopy(Type *t, bool isReturnValue,
@ -68,7 +68,7 @@ private:
// MSVC++ seems to enforce by-ref passing only for structs with
// copy ctor (incl. `= delete`).
if (isMSVCpp) {
if (t->ty == Tstruct) {
if (t->ty == TY::Tstruct) {
StructDeclaration *sd = static_cast<TypeStruct *>(t)->sym;
assert(sd);
if (sd->postblit || sd->hasCopyCtor)
@ -91,8 +91,8 @@ private:
// LDC-specific exceptions: slices and delegates are left alone (as non-
// rewritten IR structs) and passed/returned as 2 separate args => passed in
// up to 2 GP registers and returned in RAX & RDX.
return isAggregate(t) && !canRewriteAsInt(t) && t->ty != Tarray &&
t->ty != Tdelegate;
return isAggregate(t) && !canRewriteAsInt(t) && t->ty != TY::Tarray &&
t->ty != TY::Tdelegate;
}
public:
@ -127,7 +127,8 @@ public:
Type *rt = tf->next->toBasetype();
// for non-static member functions, MSVC++ enforces sret for all structs
if (isMSVC && tf->linkage == LINK::cpp && needsThis && rt->ty == Tstruct) {
if (isMSVC && tf->linkage == LINK::cpp && needsThis &&
rt->ty == TY::Tstruct) {
return true;
}

8
gen/abi-x86-64.cpp
View file

@ -188,7 +188,7 @@ private:
if (te->sym->ident == Id::__c_complex_real)
return true;
}
return rt->toBasetype()->ty == Tcomplex80;
return rt->toBasetype()->ty == TY::Tcomplex80;
}
RegCount &getRegCount(IrFuncTy &fty) {
@ -246,7 +246,7 @@ void X86_64TargetABI::rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg,
return;
}
if (t->ty == Tcomplex32 || t->ty == Tstruct || t->ty == Tsarray) {
if (t->ty == TY::Tcomplex32 || t->ty == TY::Tstruct || t->ty == TY::Tsarray) {
if (LLType *rewrittenType = getRewrittenArgType(t))
argTypesRewrite.applyToIfNotObsolete(arg, rewrittenType);
}
@ -401,11 +401,11 @@ const char *X86_64TargetABI::objcMsgSendFunc(Type *ret,
}
if (ret) {
// complex long double return
if (ret->ty == Tcomplex80) {
if (ret->ty == TY::Tcomplex80) {
return "objc_msgSend_fp2ret";
}
// long double return
if (ret->ty == Tfloat80 || ret->ty == Timaginary80) {
if (ret->ty == TY::Tfloat80 || ret->ty == TY::Timaginary80) {
return "objc_msgSend_fpret";
}
}

10
gen/abi-x86.cpp
View file

@ -118,7 +118,7 @@ struct X86TargetABI : TargetABI {
// extern(C) and all others:
// * cfloat will be rewritten as 64-bit integer and returned in registers
// * sret for cdouble and creal
return rt->ty != Tcomplex32;
return rt->ty != TY::Tcomplex32;
}
// non-extern(D): some OSs don't return structs in registers at all
@ -128,7 +128,7 @@ struct X86TargetABI : TargetABI {
const bool isMSVCpp = isMSVC && tf->linkage == LINK::cpp;
// for non-static member functions, MSVC++ enforces sret for all structs
if (isMSVCpp && needsThis && rt->ty == Tstruct) {
if (isMSVCpp && needsThis && rt->ty == TY::Tstruct) {
return true;
}
@ -160,7 +160,7 @@ struct X86TargetABI : TargetABI {
Type *rt = getExtraLoweredReturnType(fty.type);
if (isAggregate(rt) && canRewriteAsInt(rt) &&
// don't rewrite cfloat for extern(D)
!(externD && rt->ty == Tcomplex32)) {
!(externD && rt->ty == TY::Tcomplex32)) {
integerRewrite.applyToIfNotObsolete(*fty.ret);
}
}
@ -210,7 +210,7 @@ struct X86TargetABI : TargetABI {
auto sz = lastTy->size();
if (!lastTy->isfloating() && (sz == 1 || sz == 2 || sz == 4)) {
// rewrite aggregates as integers to make inreg work
if (lastTy->ty == Tstruct || lastTy->ty == Tsarray) {
if (lastTy->ty == TY::Tstruct || lastTy->ty == TY::Tsarray) {
integerRewrite.applyTo(*last);
// undo byval semantics applied via passByVal() returning true
last->byref = false;
@ -233,7 +233,7 @@ struct X86TargetABI : TargetABI {
size_t i = 0;
while (i < fty.args.size()) {
Type *type = fty.args[i]->type->toBasetype();
if (type->ty == Tstruct) {
if (type->ty == TY::Tstruct) {
// Do not pass empty structs at all for C++ ABI compatibility.
// Tests with clang reveal that more complex "empty" types, for
// example a struct containing an empty struct, are not

14
gen/abi.cpp
View file

@ -71,7 +71,7 @@ bool TargetABI::isHFVA(Type *t, int maxNumElements, LLType **hfvaType) {
bool TargetABI::isHVA(Type *t, int maxNumElements, LLType **hvaType) {
Type *rewriteType = nullptr;
if (::isHFVA(t, maxNumElements, &rewriteType) &&
rewriteType->nextOf()->ty == Tvector) {
rewriteType->nextOf()->ty == TY::Tvector) {
if (hvaType)
*hvaType = DtoType(rewriteType);
return true;
@ -118,8 +118,8 @@ bool TargetABI::isAggregate(Type *t) {
// FIXME: dynamic arrays can currently not be rewritten as they are used
// by runtime functions, for which we don't apply the rewrites yet
// when calling them
return ty == Tstruct || ty == Tsarray ||
/*ty == Tarray ||*/ ty == Tdelegate || t->iscomplex();
return ty == TY::Tstruct || ty == TY::Tsarray ||
/*ty == TY::Tarray ||*/ ty == TY::Tdelegate || t->iscomplex();
}
namespace {
@ -139,7 +139,7 @@ bool hasCtor(StructDeclaration *s) {
bool TargetABI::isPOD(Type *t, bool excludeStructsWithCtor) {
t = t->baseElemOf();
if (t->ty != Tstruct)
if (t->ty != TY::Tstruct)
return true;
StructDeclaration *sd = static_cast<TypeStruct *>(t)->sym;
return sd->isPOD() && !(excludeStructsWithCtor && hasCtor(sd));
@ -159,7 +159,7 @@ bool TargetABI::skipReturnValueRewrite(IrFuncTy &fty) {
return true;
auto ty = fty.ret->type->toBasetype()->ty;
return ty == Tvoid || ty == Tnoreturn;
return ty == TY::Tvoid || ty == TY::Tnoreturn;
}
//////////////////////////////////////////////////////////////////////////////
@ -301,7 +301,7 @@ struct IntrinsicABI : TargetABI {
void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {
Type *ty = arg.type->toBasetype();
if (ty->ty != Tstruct) {
if (ty->ty != TY::Tstruct) {
return;
}
// TODO: Check that no unions are passed in or returned.
@ -316,7 +316,7 @@ struct IntrinsicABI : TargetABI {
void rewriteFunctionType(IrFuncTy &fty) override {
if (!fty.arg_sret) {
Type *rt = fty.ret->type->toBasetype();
if (rt->ty == Tstruct) {
if (rt->ty == TY::Tstruct) {
Logger::println("Intrinsic ABI: Transforming return type");
rewriteArgument(fty, *fty.ret);
}

117
gen/arrays.cpp
View file

@ -42,7 +42,7 @@ LLValue *DtoSlice(LLValue *ptr, LLValue *length, LLType *elemType = nullptr) {
LLValue *DtoSlice(Expression *e) {
DValue *dval = toElem(e);
if (dval->type->toBasetype()->ty == Tsarray) {
if (dval->type->toBasetype()->ty == TY::Tsarray) {
// Convert static array to slice
return DtoSlice(DtoLVal(dval), DtoArrayLen(dval));
}
@ -57,11 +57,11 @@ static LLValue *DtoSlicePtr(Expression *e) {
Loc loc;
LLStructType *type = DtoArrayType(LLType::getInt8Ty(gIR->context()));
Type *vt = dval->type->toBasetype();
if (vt->ty == Tarray) {
if (vt->ty == TY::Tarray) {
return makeLValue(loc, dval);
}
bool isStaticArray = vt->ty == Tsarray;
bool isStaticArray = vt->ty == TY::Tsarray;
LLValue *val = isStaticArray ? DtoLVal(dval) : makeLValue(loc, dval);
LLValue *array = DtoRawAlloca(type, 0, ".array");
LLValue *len = isStaticArray ? DtoArrayLen(dval) : DtoConstSize_t(1);
@ -87,7 +87,7 @@ LLStructType *DtoArrayType(LLType *t) {
LLArrayType *DtoStaticArrayType(Type *t) {
t = t->toBasetype();
assert(t->ty == Tsarray);
assert(t->ty == TY::Tsarray);
TypeSArray *tsa = static_cast<TypeSArray *>(t);
Type *tnext = tsa->nextOf();
@ -179,7 +179,7 @@ static void DtoArrayInit(const Loc &loc, LLValue *ptr, LLValue *length,
static Type *DtoArrayElementType(Type *arrayType) {
assert(arrayType->toBasetype()->nextOf());
Type *t = arrayType->toBasetype()->nextOf()->toBasetype();
while (t->ty == Tsarray) {
while (t->ty == TY::Tsarray) {
t = t->nextOf()->toBasetype();
}
return t;
@ -217,7 +217,7 @@ static void copySlice(const Loc &loc, LLValue *dstarr, LLValue *dstlen,
// Determine whether t is an array of structs that need a postblit.
static bool arrayNeedsPostblit(Type *t) {
t = DtoArrayElementType(t);
if (t->ty == Tstruct) {
if (t->ty == TY::Tstruct) {
return static_cast<TypeStruct *>(t)->sym->postblit != nullptr;
}
return false;
@ -235,8 +235,8 @@ void DtoArrayAssign(const Loc &loc, DValue *lhs, DValue *rhs, int op,
assert(t->nextOf());
// reference assignment for dynamic array?
if (t->ty == Tarray && !lhs->isSlice()) {
assert(t2->ty == Tarray || t2->ty == Tsarray);
if (t->ty == TY::Tarray && !lhs->isSlice()) {
assert(t2->ty == TY::Tarray || t2->ty == TY::Tsarray);
if (rhs->isNull()) {
DtoSetArrayToNull(DtoLVal(lhs));
} else {
@ -259,8 +259,9 @@ void DtoArrayAssign(const Loc &loc, DValue *lhs, DValue *rhs, int op,
// Be careful to handle void arrays correctly when modifying this (see tests
// for DMD issue 7493).
// TODO: This should use AssignExp::memset.
LLValue *realRhsArrayPtr =
(t2->ty == Tarray || t2->ty == Tsarray) ? DtoArrayPtr(rhs) : nullptr;
LLValue *realRhsArrayPtr = (t2->ty == TY::Tarray || t2->ty == TY::Tsarray)
? DtoArrayPtr(rhs)
: nullptr;
if (realRhsArrayPtr && realRhsArrayPtr->getType() == realLhsPtr->getType()) {
// T[] = T[] T[] = T[n]
// T[n] = T[n] T[n] = T[]
@ -268,7 +269,7 @@ void DtoArrayAssign(const Loc &loc, DValue *lhs, DValue *rhs, int op,
LLValue *rhsLength = DtoArrayLen(rhs);
const bool needsPostblit = (op != TOKblit && arrayNeedsPostblit(t) &&
(!canSkipPostblit || t2->ty == Tarray));
(!canSkipPostblit || t2->ty == TY::Tarray));
if (!needsDestruction && !needsPostblit) {
// fast version
@ -278,7 +279,7 @@ void DtoArrayAssign(const Loc &loc, DValue *lhs, DValue *rhs, int op,
DtoMemSetZero(lhsPtr, lhsSize);
} else {
bool knownInBounds =
isConstructing || (t->ty == Tsarray && t2->ty == Tsarray);
isConstructing || (t->ty == TY::Tsarray && t2->ty == TY::Tsarray);
if (!knownInBounds) {
if (auto constLhsLength = llvm::dyn_cast<LLConstantInt>(lhsLength)) {
if (auto constRhsLength =
@ -368,7 +369,7 @@ LLConstant *DtoConstArrayInitializer(ArrayInitializer *arrinit,
// for statis arrays, dmd does not include any trailing default
// initialized elements in the value/index lists
if (arrty->ty == Tsarray) {
if (arrty->ty == TY::Tsarray) {
TypeSArray *tsa = static_cast<TypeSArray *>(arrty);
arrlen = static_cast<size_t>(tsa->dim->toInteger());
}
@ -383,7 +384,7 @@ LLConstant *DtoConstArrayInitializer(ArrayInitializer *arrinit,
// get elem type
Type *elemty;
if (arrty->ty == Tvector) {
if (arrty->ty == TY::Tvector) {
elemty = static_cast<TypeVector *>(arrty)->elementType();
} else {
elemty = arrty->nextOf();
@ -459,7 +460,7 @@ LLConstant *DtoConstArrayInitializer(ArrayInitializer *arrinit,
constarr = LLConstantStruct::getAnon(gIR->context(),
initvals); // FIXME should this pack?
} else {
if (arrty->ty == Tvector) {
if (arrty->ty == TY::Tvector) {
constarr = llvm::ConstantVector::get(initvals);
} else {
constarr =
@ -470,7 +471,7 @@ LLConstant *DtoConstArrayInitializer(ArrayInitializer *arrinit,
// std::cout << "constarr: " << *constarr << std::endl;
// if the type is a static array, we're done
if (arrty->ty == Tsarray || arrty->ty == Tvector) {
if (arrty->ty == TY::Tsarray || arrty->ty == TY::Tvector) {
return constarr;
}
@ -482,7 +483,7 @@ LLConstant *DtoConstArrayInitializer(ArrayInitializer *arrinit,
LLGlobalValue::InternalLinkage, constarr,
".constarray");
if (arrty->ty == Tpointer) {
if (arrty->ty == TY::Tpointer) {
// we need to return pointer to the static array.
return DtoBitCast(gvar, DtoType(arrty));
}
@ -524,7 +525,7 @@ bool isConstLiteral(Expression *e, bool immutableType) {
// If dynamic array: assume not constant because the array is expected to
// be newly allocated. See GH 1924.
Type *arrayType = ale->type->toBasetype();
if (arrayType->ty == Tarray)
if (arrayType->ty == TY::Tarray)
return false;
}
@ -786,7 +787,7 @@ DSliceValue *DtoResizeDynArray(const Loc &loc, Type *arrayType, DValue *array,
assert(array);
assert(newdim);
assert(arrayType);
assert(arrayType->toBasetype()->ty == Tarray);
assert(arrayType->toBasetype()->ty == TY::Tarray);
// decide on what runtime function to call based on whether the type is zero
// initialized
@ -997,40 +998,41 @@ LLValue *DtoArrayEqCmp_impl(const Loc &loc, const char *func, DValue *l,
/// See `validCompareWithMemcmp`.
bool validCompareWithMemcmpType(Type *t) {
switch (t->ty) {
case Tsarray: {
case TY::Tsarray: {
auto *elemType = t->baseElemOf();
return validCompareWithMemcmpType(elemType);
}
case Tstruct:
case TY::Tstruct:
// TODO: Implement when structs can be compared with memcmp. Remember that
// structs can have a user-defined opEquals, alignment padding bytes (in
// arrays), and padding bytes.
return false;
case Tvoid:
case Tint8:
case Tuns8:
case Tint16:
case Tuns16:
case Tint32:
case Tuns32:
case Tint64:
case Tuns64:
case Tint128:
case Tuns128:
case Tbool:
case Tchar:
case Twchar:
case Tdchar:
case Tpointer:
case TY::Tvoid:
case TY::Tint8:
case TY::Tuns8:
case TY::Tint16:
case TY::Tuns16:
case TY::Tint32:
case TY::Tuns32:
case TY::Tint64:
case TY::Tuns64:
case TY::Tint128:
case TY::Tuns128:
case TY::Tbool:
case TY::Tchar:
case TY::Twchar:
case TY::Tdchar:
case TY::Tpointer:
return true;
// TODO: Determine whether this can be "return true" too:
// case Tvector:
}
// case TY::Tvector:
return false;
default:
return false;
}
}
/// When `true` is returned, `l` and `r` can be compared using `memcmp`.
@ -1086,8 +1088,9 @@ LLValue *DtoArrayEqCmp_memcmp(const Loc &loc, DValue *l, DValue *r,
auto *l_length = DtoArrayLen(l);
// Early return for the simple case of comparing two static arrays.
const bool staticArrayComparison = (l->type->toBasetype()->ty == Tsarray) &&
(r->type->toBasetype()->ty == Tsarray);
const bool staticArrayComparison =
(l->type->toBasetype()->ty == TY::Tsarray) &&
(r->type->toBasetype()->ty == TY::Tsarray);
if (staticArrayComparison) {
// TODO: simply codegen when comparing static arrays with different length (int[3] == int[2])
return callMemcmp(loc, irs, l_ptr, r_ptr, l_length);
@ -1165,7 +1168,7 @@ LLValue *DtoArrayLen(DValue *v) {
LOG_SCOPE;
Type *t = v->type->toBasetype();
if (t->ty == Tarray) {
if (t->ty == TY::Tarray) {
if (v->isNull()) {
return DtoConstSize_t(0);
}
@ -1176,7 +1179,7 @@ LLValue *DtoArrayLen(DValue *v) {
assert(slice);
return slice->getLength();
}
if (t->ty == Tsarray) {
if (t->ty == TY::Tsarray) {
assert(!v->isSlice());
assert(!v->isNull());
TypeSArray *sarray = static_cast<TypeSArray *>(t);
@ -1196,7 +1199,7 @@ LLValue *DtoArrayPtr(DValue *v) {
LLType *wantedLLPtrType = DtoPtrToType(t->nextOf());
LLValue *ptr = nullptr;
if (t->ty == Tarray) {
if (t->ty == TY::Tarray) {
if (v->isNull()) {
ptr = getNullPtr(wantedLLPtrType);
} else if (v->isLVal()) {
@ -1206,7 +1209,7 @@ LLValue *DtoArrayPtr(DValue *v) {
assert(slice);
ptr = slice->getPtr();
}
} else if (t->ty == Tsarray) {
} else if (t->ty == TY::Tsarray) {
assert(!v->isSlice());
assert(!v->isNull());
ptr = DtoLVal(v);
@ -1226,14 +1229,14 @@ DValue *DtoCastArray(const Loc &loc, DValue *u, Type *to) {
Type *totype = to->toBasetype();
Type *fromtype = u->type->toBasetype();
if (fromtype->ty != Tarray && fromtype->ty != Tsarray) {
if (fromtype->ty != TY::Tarray && fromtype->ty != TY::Tsarray) {
error(loc, "can't cast `%s` to `%s`", u->type->toChars(), to->toChars());
fatal();
}
IF_LOG Logger::cout() << "from array or sarray" << '\n';
if (totype->ty == Tpointer) {
if (totype->ty == TY::Tpointer) {
IF_LOG Logger::cout() << "to pointer" << '\n';
LLValue *ptr = DtoArrayPtr(u);
if (ptr->getType() != tolltype) {
@ -1242,12 +1245,12 @@ DValue *DtoCastArray(const Loc &loc, DValue *u, Type *to) {
return new DImValue(to, ptr);
}
if (totype->ty == Tarray) {
if (totype->ty == TY::Tarray) {
IF_LOG Logger::cout() << "to array" << '\n';
LLValue *length = nullptr;
LLValue *ptr = nullptr;
if (fromtype->ty == Tsarray) {
if (fromtype->ty == TY::Tsarray) {
length = DtoConstSize_t(
static_cast<TypeSArray *>(fromtype)->dim->toUInteger());
ptr = DtoLVal(u);
@ -1282,11 +1285,11 @@ DValue *DtoCastArray(const Loc &loc, DValue *u, Type *to) {
return new DSliceValue(to, length, DtoBitCast(ptr, ptrty));
}
if (totype->ty == Tsarray) {
if (totype->ty == TY::Tsarray) {
IF_LOG Logger::cout() << "to sarray" << '\n';
LLValue *ptr = nullptr;
if (fromtype->ty == Tsarray) {
if (fromtype->ty == TY::Tsarray) {
ptr = DtoLVal(u);
} else {
size_t tosize = static_cast<TypeSArray *>(totype)->dim->toInteger();
@ -1300,7 +1303,7 @@ DValue *DtoCastArray(const Loc &loc, DValue *u, Type *to) {
return new DLValue(to, DtoBitCast(ptr, getPtrToType(tolltype)));
}
if (totype->ty == Tbool) {
if (totype->ty == TY::Tbool) {
// return (arr.ptr !is null)
LLValue *ptr = DtoArrayPtr(u);
LLConstant *nul = getNullPtr(ptr->getType());
@ -1313,16 +1316,16 @@ DValue *DtoCastArray(const Loc &loc, DValue *u, Type *to) {
void DtoIndexBoundsCheck(const Loc &loc, DValue *arr, DValue *index) {
Type *arrty = arr->type->toBasetype();
assert(
(arrty->ty == Tsarray || arrty->ty == Tarray || arrty->ty == Tpointer) &&
"Can only array bounds check for static or dynamic arrays");
assert((arrty->ty == TY::Tsarray || arrty->ty == TY::Tarray ||
arrty->ty == TY::Tpointer) &&
"Can only array bounds check for static or dynamic arrays");
if (!index) {
// Caller supplied no index, known in-bounds.
return;
}
if (arrty->ty == Tpointer) {
if (arrty->ty == TY::Tpointer) {
// Length of pointers is unknown, ingore.
return;
}

2
gen/asm-x86.h
View file

@ -3185,7 +3185,7 @@ struct AsmProcessor {
// Tfloat64
TY ty = v->type->toBasetype()->ty;
operand->dataSizeHint =
(ty == Tfloat80 || ty == Timaginary80) &&
(ty == TY::Tfloat80 || ty == TY::Timaginary80) &&
!global.params.targetTriple->isWindowsMSVCEnvironment()
? Extended_Ptr
: static_cast<PtrType>(v->type->size(Loc()));

2
gen/asmstmt.cpp
View file

@ -606,7 +606,7 @@ void CompoundAsmStatement_toIR(CompoundAsmStatement *stmt, IRState *p) {
bool useabiret = false;
p->asmBlock->asmBlock->abiret = nullptr;
if (thisfunc->fbody->endsWithAsm() == stmt &&
thisfunc->type->nextOf()->ty != Tvoid) {
thisfunc->type->nextOf()->ty != TY::Tvoid) {
// there can't be goto forwarders in this case
assert(gotoToVal.empty());
emitABIReturnAsmStmt(asmblock, stmt->loc, thisfunc);

18
gen/binops.cpp
View file

@ -22,7 +22,7 @@
//////////////////////////////////////////////////////////////////////////////
dinteger_t undoStrideMul(const Loc &loc, Type *t, dinteger_t offset) {
assert(t->ty == Tpointer);
assert(t->ty == TY::Tpointer);
d_uns64 elemSize = t->nextOf()->size(loc);
assert((offset % elemSize) == 0 &&
"Expected offset by an integer amount of elements");
@ -127,7 +127,7 @@ DValue *emitPointerOffset(Loc loc, DValue *base, Expression *offset,
// a null constant and returns the other operand (AA) as new DImValue.
// Returns null if type is not an AA.
DValue *isAssociativeArrayAndNull(Type *type, LLValue *lhs, LLValue *rhs) {
if (type->ty != Taarray)
if (type->ty != TY::Taarray)
return nullptr;
if (auto constantL = isaConstant(lhs)) {
@ -151,14 +151,15 @@ DValue *binAdd(const Loc &loc, Type *type, DValue *lhs, Expression *rhs,
Type *lhsType = lhs->type->toBasetype();
Type *rhsType = rhs->type->toBasetype();
if (lhsType != rhsType && lhsType->ty == Tpointer && rhsType->isintegral()) {
if (lhsType != rhsType && lhsType->ty == TY::Tpointer &&
rhsType->isintegral()) {
Logger::println("Adding integer to pointer");
return emitPointerOffset(loc, lhs, rhs, false, type, loadLhsAfterRhs);
}
auto rvals = evalSides(lhs, rhs, loadLhsAfterRhs);
if (type->ty == Tnull)
if (type->ty == TY::Tnull)
return DtoNullValue(type, loc);
if (type->iscomplex())
return DtoComplexAdd(loc, type, rvals.lhs, rvals.rhs);
@ -182,14 +183,15 @@ DValue *binMin(const Loc &loc, Type *type, DValue *lhs, Expression *rhs,
Type *lhsType = lhs->type->toBasetype();
Type *rhsType = rhs->type->toBasetype();
if (lhsType != rhsType && lhsType->ty == Tpointer && rhsType->isintegral()) {
if (lhsType != rhsType && lhsType->ty == TY::Tpointer &&
rhsType->isintegral()) {
Logger::println("Subtracting integer from pointer");
return emitPointerOffset(loc, lhs, rhs, true, type, loadLhsAfterRhs);
}
auto rvals = evalSides(lhs, rhs, loadLhsAfterRhs);
if (lhsType->ty == Tpointer && rhsType->ty == Tpointer) {
if (lhsType->ty == TY::Tpointer && rhsType->ty == TY::Tpointer) {
LLValue *l = DtoRVal(rvals.lhs);
LLValue *r = DtoRVal(rvals.rhs);
LLType *llSizeT = DtoSize_t();
@ -202,7 +204,7 @@ DValue *binMin(const Loc &loc, Type *type, DValue *lhs, Expression *rhs,
return new DImValue(type, diff);
}
if (type->ty == Tnull)
if (type->ty == TY::Tnull)
return DtoNullValue(type, loc);
if (type->iscomplex())
return DtoComplexMin(loc, type, rvals.lhs, rvals.rhs);
@ -366,7 +368,7 @@ LLValue *DtoBinFloatsEquals(const Loc &loc, DValue *lhs, DValue *rhs, TOK op) {
LLValue *r = DtoRVal(rhs);
res = (op == TOKequal ? gIR->ir->CreateFCmpOEQ(l, r)
: gIR->ir->CreateFCmpUNE(l, r));
if (lhs->type->toBasetype()->ty == Tvector) {
if (lhs->type->toBasetype()->ty == TY::Tvector) {
res = mergeVectorEquals(res, op);
}
} else {

10
gen/classes.cpp
View file

@ -231,14 +231,14 @@ DValue *DtoCastClass(const Loc &loc, DValue *val, Type *_to) {
Type *to = _to->toBasetype();
// class -> pointer
if (to->ty == Tpointer) {
if (to->ty == TY::Tpointer) {
IF_LOG Logger::println("to pointer");
LLType *tolltype = DtoType(_to);
LLValue *rval = DtoBitCast(DtoRVal(val), tolltype);
return new DImValue(_to, rval);
}
// class -> bool
if (to->ty == Tbool) {
if (to->ty == TY::Tbool) {
IF_LOG Logger::println("to bool");
LLValue *llval = DtoRVal(val);
LLValue *zero = LLConstant::getNullValue(llval->getType());
@ -257,13 +257,13 @@ DValue *DtoCastClass(const Loc &loc, DValue *val, Type *_to) {
return DtoCastInt(loc, &im, _to);
}
// class -> typeof(null)
if (to->ty == Tnull) {
if (to->ty == TY::Tnull) {
IF_LOG Logger::println("to %s", to->toChars());
return new DImValue(_to, LLConstant::getNullValue(DtoType(_to)));
}
// must be class/interface
assert(to->ty == Tclass);
assert(to->ty == TY::Tclass);
TypeClass *tc = static_cast<TypeClass *>(to);
// from type
@ -416,7 +416,7 @@ LLValue *DtoVirtualFunctionPointer(DValue *inst, FuncDeclaration *fdecl) {
// sanity checks
assert(fdecl->isVirtual());
assert(!fdecl->isFinalFunc());
assert(inst->type->toBasetype()->ty == Tclass);
assert(inst->type->toBasetype()->ty == TY::Tclass);
// slot 0 is always ClassInfo/Interface* unless it is a CPP class
assert(fdecl->vtblIndex > 0 ||
(fdecl->vtblIndex == 0 &&

44
gen/complex.cpp
View file

@ -33,12 +33,12 @@ LLType *DtoComplexBaseType(Type *t) {
switch (t->toBasetype()->ty) {
default:
llvm_unreachable("Unexpected complex floating point type");
case Tcomplex32:
return DtoType(Type::basic[Tfloat32]);
case Tcomplex64:
return DtoType(Type::basic[Tfloat64]);
case Tcomplex80:
return DtoType(Type::basic[Tfloat80]);
case TY::Tcomplex32:
return DtoType(Type::tfloat32);
case TY::Tcomplex64:
return DtoType(Type::tfloat64);
case TY::Tcomplex80:
return DtoType(Type::tfloat80);
}
}
@ -49,13 +49,13 @@ LLConstant *DtoConstComplex(Type *_ty, real_t re, real_t im) {
switch (_ty->toBasetype()->ty) {
default:
llvm_unreachable("Unexpected complex floating point type");
case Tcomplex32:
case TY::Tcomplex32:
base = Type::tfloat32;
break;
case Tcomplex64:
case TY::Tcomplex64:
base = Type::tfloat64;
break;
case Tcomplex80:
case TY::Tcomplex80:
base = Type::tfloat80;
break;
}
@ -76,15 +76,15 @@ DValue *DtoComplex(const Loc &loc, Type *to, DValue *val) {
switch (to->toBasetype()->ty) {
default:
llvm_unreachable("Unexpected complex floating point type");
case Tcomplex32:
case TY::Tcomplex32:
baserety = Type::tfloat32;
baseimty = Type::timaginary32;
break;
case Tcomplex64:
case TY::Tcomplex64:
baserety = Type::tfloat64;
baseimty = Type::timaginary64;
break;
case Tcomplex80:
case TY::Tcomplex80:
baserety = Type::tfloat80;
baseimty = Type::timaginary80;
break;
@ -121,15 +121,15 @@ void DtoGetComplexParts(const Loc &loc, Type *to, DValue *val, DValue *&re,
switch (to->toBasetype()->ty) {
default:
llvm_unreachable("Unexpected complex floating point type");
case Tcomplex32:
case TY::Tcomplex32:
baserety = Type::tfloat32;
baseimty = Type::timaginary32;
break;
case Tcomplex64:
case TY::Tcomplex64:
baserety = Type::tfloat64;
baseimty = Type::timaginary64;
break;
case Tcomplex80:
case TY::Tcomplex80:
baserety = Type::tfloat80;
baseimty = Type::timaginary80;
break;
@ -462,20 +462,20 @@ DValue *DtoCastComplex(const Loc &loc, DValue *val, Type *_to) {
switch (vty->ty) {
default:
llvm_unreachable("Unexpected complex floating point type");
case Tcomplex32:
case TY::Tcomplex32:
extractty = Type::timaginary32;
break;
case Tcomplex64:
case TY::Tcomplex64:
extractty = Type::timaginary64;
break;
case Tcomplex80:
case TY::Tcomplex80:
extractty = Type::timaginary80;
break;
}
auto im = new DImValue(extractty, impart);
return DtoCastFloat(loc, im, to);
}
if (to->ty == Tbool) {
if (to->ty == TY::Tbool) {
return new DImValue(
_to, DtoComplexEquals(loc, TOKnotequal, val, DtoNullValue(vty)));
}
@ -487,13 +487,13 @@ DValue *DtoCastComplex(const Loc &loc, DValue *val, Type *_to) {
switch (vty->ty) {
default:
llvm_unreachable("Unexpected complex floating point type");
case Tcomplex32:
case TY::Tcomplex32:
extractty = Type::tfloat32;
break;
case Tcomplex64:
case TY::Tcomplex64:
extractty = Type::tfloat64;
break;
case Tcomplex80:
case TY::Tcomplex80:
extractty = Type::tfloat80;
break;
}

12
gen/dcompute/targetOCL.cpp
View file

@ -142,17 +142,17 @@ public:
std::string basicTypeToString(Type *t) {
std::stringstream ss;
auto ty = t->ty;
if (ty == Tint8)
if (ty == TY::Tint8)
ss << "char";
else if (ty == Tuns8)
else if (ty == TY::Tuns8)
ss << "uchar";
else if (ty == Tvector) {
else if (ty == TY::Tvector) {
TypeVector *vec = static_cast<TypeVector *>(t);
auto size = vec->size(Loc());
auto basety = vec->basetype->ty;
if (basety == Tint8)
if (basety == TY::Tint8)
ss << "char";
else if (basety == Tuns8)
else if (basety == TY::Tuns8)
ss << "uchar";
else
ss << vec->basetype->toChars();
@ -171,7 +171,7 @@ public:
std::string tyName;
std::string accessQual = "none";
int addrspace = 0;
if (v->type->ty == Tstruct &&
if (v->type->ty == TY::Tstruct &&
(ptr = toDcomputePointer(static_cast<TypeStruct *>(v->type)->sym))) {
addrspace = ptr->addrspace;
tyName = basicTypeToString(ptr->type) + "*";

10
gen/declarations.cpp
View file

@ -86,7 +86,7 @@ public:
return;
}
if (decl->type->ty == Terror) {
if (decl->type->ty == TY::Terror) {
decl->error("had semantic errors when compiling");
decl->ir->setDefined();
return;
@ -122,7 +122,7 @@ public:
return;
}
if (decl->type->ty == Terror) {
if (decl->type->ty == TY::Terror) {
decl->error("had semantic errors when compiling");
decl->ir->setDefined();
return;
@ -181,7 +181,7 @@ public:
return;
}
if (decl->type->ty == Terror) {
if (decl->type->ty == TY::Terror) {
decl->error("had semantic errors when compiling");
decl->ir->setDefined();
return;
@ -245,7 +245,7 @@ public:
return;
}
if (decl->type->ty == Terror) {
if (decl->type->ty == TY::Terror) {
decl->error("had semantic errors when compiling");
decl->ir->setDefined();
return;
@ -279,7 +279,7 @@ public:
IF_LOG Logger::println("Ignoring EnumDeclaration::codegen: '%s'",
decl->toPrettyChars());
if (decl->type->ty == Terror) {
if (decl->type->ty == TY::Terror) {
decl->error("had semantic errors when compiling");
return;
}

76
gen/dibuilder.cpp
View file

@ -250,54 +250,54 @@ DIType DIBuilder::CreateBasicType(Type *type) {
// find encoding
unsigned Encoding;
switch (t->ty) {
case Tbool:
case TY::Tbool:
Encoding = DW_ATE_boolean;
break;
case Tchar:
case TY::Tchar:
if (emitCodeView) {
// VS debugger does not support DW_ATE_UTF for char
Encoding = DW_ATE_unsigned_char;
break;
}
// fall through
case Twchar:
case Tdchar:
case TY::Twchar:
case TY::Tdchar:
Encoding = DW_ATE_UTF;
break;
case Tint8:
case TY::Tint8:
if (emitCodeView) {
// VS debugger does not support DW_ATE_signed for 8-bit
Encoding = DW_ATE_signed_char;
break;
}
// fall through
case Tint16:
case Tint32:
case Tint64:
case Tint128:
case TY::Tint16:
case TY::Tint32:
case TY::Tint64:
case TY::Tint128:
Encoding = DW_ATE_signed;
break;
case Tuns8:
case TY::Tuns8:
if (emitCodeView) {
// VS debugger does not support DW_ATE_unsigned for 8-bit
Encoding = DW_ATE_unsigned_char;
break;
}
// fall through
case Tuns16:
case Tuns32:
case Tuns64:
case Tuns128:
case TY::Tuns16:
case TY::Tuns32:
case TY::Tuns64:
case TY::Tuns128:
Encoding = DW_ATE_unsigned;
break;
case Tfloat32:
case Tfloat64:
case Tfloat80:
case TY::Tfloat32:
case TY::Tfloat64:
case TY::Tfloat80:
Encoding = DW_ATE_float;
break;
case Timaginary32:
case Timaginary64:
case Timaginary80:
case TY::Timaginary32:
case TY::Timaginary64:
case TY::Timaginary80:
if (emitCodeView) {
// DW_ATE_imaginary_float not supported by the LLVM DWARF->CodeView
// conversion
@ -306,9 +306,9 @@ DIType DIBuilder::CreateBasicType(Type *type) {
}
Encoding = DW_ATE_imaginary_float;
break;
case Tcomplex32:
case Tcomplex64:
case Tcomplex80:
case TY::Tcomplex32:
case TY::Tcomplex64:
case TY::Tcomplex80:
if (emitCodeView) {
// DW_ATE_complex_float not supported by the LLVM DWARF->CodeView
// conversion
@ -408,13 +408,13 @@ DIType DIBuilder::CreateComplexType(Type *type) {
Type *elemtype = nullptr;
switch (t->ty) {
case Tcomplex32:
case TY::Tcomplex32:
elemtype = Type::tfloat32;
break;
case Tcomplex64:
case TY::Tcomplex64:
elemtype = Type::tfloat64;
break;
case Tcomplex80:
case TY::Tcomplex80:
elemtype = Type::tfloat80;
break;
default:
@ -531,11 +531,11 @@ void DIBuilder::AddStaticMembers(AggregateDeclaration *ad, DIFile file,
}
DIType DIBuilder::CreateCompositeType(Type *t) {
assert((t->ty == Tstruct || t->ty == Tclass) &&
assert((t->ty == TY::Tstruct || t->ty == TY::Tclass) &&
"Unsupported type for debug info in DIBuilder::CreateCompositeType");
AggregateDeclaration *ad;
if (t->ty == Tstruct) {
if (t->ty == TY::Tstruct) {
ad = static_cast<TypeStruct *>(t)->sym;
} else {
ad = static_cast<TypeClass *>(t)->sym;
@ -544,7 +544,7 @@ DIType DIBuilder::CreateCompositeType(Type *t) {
// Use the actual type associated with the declaration, ignoring any
// const/wrappers.
LLType *T = DtoType(ad->type);
if (t->ty == Tclass)
if (t->ty == TY::Tclass)
T = T->getPointerElementType();
IrAggr *irAggr = getIrAggr(ad, true);
@ -578,8 +578,8 @@ DIType DIBuilder::CreateCompositeType(Type *t) {
const auto uniqueIdentifier = uniqueIdent(t);
// set diCompositeType to handle recursive types properly
unsigned tag = (t->ty == Tstruct) ? llvm::dwarf::DW_TAG_structure_type
: llvm::dwarf::DW_TAG_class_type;
unsigned tag = (t->ty == TY::Tstruct) ? llvm::dwarf::DW_TAG_structure_type
: llvm::dwarf::DW_TAG_class_type;
irAggr->diCompositeType =
DBuilder.createReplaceableCompositeType(tag, name, scope, file, lineNum);
@ -604,7 +604,7 @@ DIType DIBuilder::CreateCompositeType(Type *t) {
const auto elemsArray = DBuilder.getOrCreateArray(elems);
DIType ret;
if (t->ty == Tclass) {
if (t->ty == TY::Tclass) {
ret = DBuilder.createClassType(
scope, name, file, lineNum, sizeInBits, alignmentInBits,
classOffsetInBits, DIFlags::FlagZero, derivedFrom, elemsArray,
@ -653,7 +653,7 @@ DIType DIBuilder::CreateSArrayType(TypeSArray *type) {
Type *te = type;
llvm::SmallVector<LLMetadata *, 8> subscripts;
for (; te->ty == Tsarray; te = te->nextOf()) {
for (; te->ty == TY::Tsarray; te = te->nextOf()) {
TypeSArray *tsa = static_cast<TypeSArray *>(te);
const auto count = tsa->dim->toInteger();
#if LDC_LLVM_VER >= 1100
@ -762,12 +762,12 @@ DIType DIBuilder::CreateUnspecifiedType(Dsymbol *sym) {
////////////////////////////////////////////////////////////////////////////////
DIType DIBuilder::CreateTypeDescription(Type *t, bool voidToUbyte) {
if (voidToUbyte && t->toBasetype()->ty == Tvoid)
if (voidToUbyte && t->toBasetype()->ty == TY::Tvoid)
t = Type::tuns8;
if (t->ty == Tvoid || t->ty == Tnoreturn)
if (t->ty == TY::Tvoid || t->ty == TY::Tnoreturn)
return nullptr;
if (t->ty == Tnull) {
if (t->ty == TY::Tnull) {
// display null as void*
return DBuilder.createPointerType(CreateTypeDescription(Type::tvoid), 8, 8,
/* DWARFAddressSpace */ llvm::None,
@ -787,7 +787,7 @@ DIType DIBuilder::CreateTypeDescription(Type *t, bool voidToUbyte) {
return CreateSArrayType(tsa);
if (auto taa = t->isTypeAArray())
return CreateAArrayType(taa);
if (t->ty == Tstruct)
if (t->ty == TY::Tstruct)
return CreateCompositeType(t);
if (auto tc = t->isTypeClass()) {
LLType *T = DtoType(t);
@ -1193,7 +1193,7 @@ void DIBuilder::EmitLocalVariable(llvm::Value *ll, VarDeclaration *vd,
} else {
// 2) dynamic arrays, delegates and vectors
TY ty = type->toBasetype()->ty;
if (ty == Tarray || ty == Tdelegate || ty == Tvector)
if (ty == TY::Tarray || ty == TY::Tdelegate || ty == TY::Tvector)
forceAsLocal = true;
}
}

13
gen/dvalue.cpp
View file

@ -67,9 +67,10 @@ DImValue::DImValue(Type *t, llvm::Value *v) : DRValue(t, v) {
// TODO: get rid of Tfunction exception
// v may be an addrspace qualified pointer so strip it before doing a pointer
// equality check.
assert(t->toBasetype()->ty == Tfunction ||
assert(t->toBasetype()->ty == TY::Tfunction ||
stripAddrSpaces(v->getType()) == DtoType(t));
assert(t->toBasetype()->ty != Tarray && "use DSliceValue for dynamic arrays");
assert(t->toBasetype()->ty != TY::Tarray &&
"use DSliceValue for dynamic arrays");
}
////////////////////////////////////////////////////////////////////////////////
@ -82,7 +83,7 @@ DConstValue::DConstValue(Type *t, LLConstant *con) : DRValue(t, con) {
DSliceValue::DSliceValue(Type *t, LLValue *pair, LLValue *length, LLValue *ptr)
: DRValue(t, pair), length(length), ptr(ptr) {
assert(t->toBasetype()->ty == Tarray);
assert(t->toBasetype()->ty == TY::Tarray);
// v may be an addrspace qualified pointer so strip it before doing a pointer
// equality check.
assert(stripAddrSpaces(pair->getType()) == DtoType(t));
@ -120,7 +121,7 @@ bool DFuncValue::definedInFuncEntryBB() {
DLValue::DLValue(Type *t, LLValue *v) : DValue(t, v) {
// v may be an addrspace qualified pointer so strip it before doing a pointer
// equality check.
assert(t->toBasetype()->ty == Ttuple ||
assert(t->toBasetype()->ty == TY::Ttuple ||
stripAddrSpaces(v->getType()) == DtoPtrToType(t));
}
@ -133,7 +134,7 @@ DRValue *DLValue::getRVal() {
LLValue *rval = DtoLoad(val);
const auto ty = type->toBasetype()->ty;
if (ty == Tbool) {
if (ty == TY::Tbool) {
assert(rval->getType() == llvm::Type::getInt8Ty(gIR->context()));
if (isOptimizationEnabled()) {
@ -146,7 +147,7 @@ DRValue *DLValue::getRVal() {
// truncate to i1
rval = gIR->ir->CreateTrunc(rval, llvm::Type::getInt1Ty(gIR->context()));
} else if (ty == Tarray) {
} else if (ty == TY::Tarray) {
return new DSliceValue(type, rval);
}

26
gen/functions.cpp
View file

@ -68,7 +68,7 @@ llvm::FunctionType *DtoFunctionType(Type *type, IrFuncTy &irFty, Type *thistype,
LOG_SCOPE
// sanity check
assert(type->ty == Tfunction);
assert(type->ty == TY::Tfunction);
TypeFunction *f = static_cast<TypeFunction *>(type);
assert(f->next && "Encountered function type with invalid return type; "
"trying to codegen function ignored by the frontend?");
@ -94,7 +94,7 @@ llvm::FunctionType *DtoFunctionType(Type *type, IrFuncTy &irFty, Type *thistype,
newIrFty.ret = new IrFuncTyArg(Type::tint32, false);
} else {
Type *rt = f->next;
const bool byref = f->isref() && rt->toBasetype()->ty != Tvoid;
const bool byref = f->isref() && rt->toBasetype()->ty != TY::Tvoid;
llvm::AttrBuilder attrs;
if (abi->returnInArg(f, fd && fd->needThis())) {
@ -126,8 +126,8 @@ llvm::FunctionType *DtoFunctionType(Type *type, IrFuncTy &irFty, Type *thistype,
if (fd && fd->isCtorDeclaration()) {
attrs.addAttribute(LLAttribute::Returned);
}
newIrFty.arg_this =
new IrFuncTyArg(thistype, thistype->toBasetype()->ty == Tstruct, attrs);
newIrFty.arg_this = new IrFuncTyArg(
thistype, thistype->toBasetype()->ty == TY::Tstruct, attrs);
++nextLLArgIdx;
} else if (nesttype) {
// Add the context pointer for nested functions
@ -377,9 +377,9 @@ void DtoResolveFunction(FuncDeclaration *fdecl, const bool willDeclare) {
Type *type = fdecl->type;
// If errors occurred compiling it, such as bugzilla 6118
if (type && type->ty == Tfunction) {
if (type && type->ty == TY::Tfunction) {
Type *next = static_cast<TypeFunction *>(type)->next;
if (!next || next->ty == Terror) {
if (!next || next->ty == TY::Terror) {
return;
}
}
@ -422,7 +422,7 @@ void DtoResolveFunction(FuncDeclaration *fdecl, const bool willDeclare) {
fdecl->llvmInternal = LLVMinline_ir;
fdecl->linkage = LINK::c;
Type *type = fdecl->type;
assert(type->ty == Tfunction);
assert(type->ty == TY::Tfunction);
static_cast<TypeFunction *>(type)->linkage = LINK::c;
DtoFunctionType(fdecl);
@ -679,7 +679,7 @@ void DtoDeclareFunction(FuncDeclaration *fdecl, const bool willDefine) {
// the codegen options allow skipping PLT.
func->addFnAttr(LLAttribute::NonLazyBind);
}
if (f->next->toBasetype()->ty == Tnoreturn) {
if (f->next->toBasetype()->ty == TY::Tnoreturn) {
func->addFnAttr(LLAttribute::NoReturn);
}
@ -1033,11 +1033,11 @@ void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally) {
return;
}
if ((fd->type && fd->type->ty == Terror) ||
(fd->type && fd->type->ty == Tfunction &&
if ((fd->type && fd->type->ty == TY::Terror) ||
(fd->type && fd->type->ty == TY::Tfunction &&
static_cast<TypeFunction *>(fd->type)->next == nullptr) ||
(fd->type && fd->type->ty == Tfunction &&
static_cast<TypeFunction *>(fd->type)->next->ty == Terror)) {
(fd->type && fd->type->ty == TY::Tfunction &&
static_cast<TypeFunction *>(fd->type)->next->ty == TY::Terror)) {
IF_LOG Logger::println(
"Ignoring; has error type, no return type or returns error type");
fd->ir->setDefined();
@ -1400,7 +1400,7 @@ DValue *DtoArgument(Parameter *fnarg, Expression *argexp) {
// lazy arg
if (fnarg && (fnarg->storageClass & STClazy)) {
assert(argexp->type->toBasetype()->ty == Tdelegate);
assert(argexp->type->toBasetype()->ty == TY::Tdelegate);
assert(!arg->isLVal());
return arg;
}

2
gen/inlineir.cpp
View file

@ -177,7 +177,7 @@ DValue *DtoInlineIRExpr(const Loc &loc, FuncDeclaration *fdecl,
}
stream << ")\n{\n" << code;
if (ret->ty == Tvoid) {
if (ret->ty == TY::Tvoid) {
stream << "\nret void";
}
stream << "\n}";

2
gen/irstate.cpp
View file

@ -128,7 +128,7 @@ bool IRState::emitArrayBoundsChecks() {
}
Type *t = func()->decl->type;
return t->ty == Tfunction && ((TypeFunction *)t)->trust == TRUST::safe;
return t->ty == TY::Tfunction && ((TypeFunction *)t)->trust == TRUST::safe;
}
LLConstant *

127
gen/llvmhelpers.cpp
View file

@ -135,7 +135,7 @@ void DtoDeleteArray(const Loc &loc, DValue *arr) {
// the TypeInfo argument must be null if the type has no dtor
Type *elementType = arr->type->nextOf();
bool hasDtor = (elementType->toBasetype()->ty == Tstruct &&
bool hasDtor = (elementType->toBasetype()->ty == TY::Tstruct &&
elementType->needsDestruction());
LLValue *typeInfo = !hasDtor ? getNullPtr(fty->getParamType(1))
: DtoTypeInfoOf(loc, elementType);
@ -367,11 +367,11 @@ void DtoAssign(const Loc &loc, DValue *lhs, DValue *rhs, int op,
LOG_SCOPE;
Type *t = lhs->type->toBasetype();
assert(t->ty != Tvoid && "Cannot assign values of type void.");
assert(t->ty != TY::Tvoid && "Cannot assign values of type void.");
if (t->ty == Tbool) {
if (t->ty == TY::Tbool) {
DtoStoreZextI8(DtoRVal(rhs), DtoLVal(lhs));
} else if (t->ty == Tstruct) {
} else if (t->ty == TY::Tstruct) {
// don't copy anything to empty structs
if (static_cast<TypeStruct *>(t)->sym->fields.length > 0) {
llvm::Value *src = DtoLVal(rhs);
@ -383,9 +383,9 @@ void DtoAssign(const Loc &loc, DValue *lhs, DValue *rhs, int op,
if (src != dst)
DtoMemCpy(dst, src);
}
} else if (t->ty == Tarray || t->ty == Tsarray) {
} else if (t->ty == TY::Tarray || t->ty == TY::Tsarray) {
DtoArrayAssign(loc, lhs, rhs, op, canSkipPostblit);
} else if (t->ty == Tdelegate) {
} else if (t->ty == TY::Tdelegate) {
LLValue *l = DtoLVal(lhs);
LLValue *r = DtoRVal(rhs);
IF_LOG {
@ -393,8 +393,8 @@ void DtoAssign(const Loc &loc, DValue *lhs, DValue *rhs, int op,
Logger::cout() << "rhs: " << *r << '\n';
}
DtoStore(r, l);
} else if (t->ty == Tclass) {
assert(rhs->type->toBasetype()->ty == Tclass);
} else if (t->ty == TY::Tclass) {
assert(rhs->type->toBasetype()->ty == TY::Tclass);
LLValue *l = DtoLVal(lhs);
LLValue *r = DtoRVal(rhs);
IF_LOG {
@ -454,13 +454,13 @@ DValue *DtoNullValue(Type *type, Loc loc) {
}
// integer, floating, pointer, assoc array, delegate and class have no special
// representation
if (basetype->isintegral() || basetype->isfloating() || basety == Tpointer ||
basety == Tnull || basety == Tclass || basety == Tdelegate ||
basety == Taarray) {
if (basetype->isintegral() || basetype->isfloating() ||
basety == TY::Tpointer || basety == TY::Tnull || basety == TY::Tclass ||
basety == TY::Tdelegate || basety == TY::Taarray) {
return new DNullValue(type, LLConstant::getNullValue(lltype));
}
// dynamic array
if (basety == Tarray) {
if (basety == TY::Tarray) {
LLValue *len = DtoConstSize_t(0);
LLValue *ptr = getNullPtr(DtoPtrToType(basetype->nextOf()));
return new DSliceValue(type, len, ptr);
@ -488,13 +488,13 @@ DValue *DtoCastInt(const Loc &loc, DValue *val, Type *_to) {
size_t fromsz = from->size();
size_t tosz = to->size();
if (to->ty == Tbool) {
if (to->ty == TY::Tbool) {
LLValue *zero = LLConstantInt::get(rval->getType(), 0, false);
rval = gIR->ir->CreateICmpNE(rval, zero);
} else if (to->isintegral()) {
if (fromsz < tosz || from->ty == Tbool) {
if (fromsz < tosz || from->ty == TY::Tbool) {
IF_LOG Logger::cout() << "cast to: " << *tolltype << '\n';
if (isLLVMUnsigned(from) || from->ty == Tbool) {
if (isLLVMUnsigned(from) || from->ty == TY::Tbool) {
rval = new llvm::ZExtInst(rval, tolltype, "", gIR->scopebb());
} else {
rval = new llvm::SExtInst(rval, tolltype, "", gIR->scopebb());
@ -512,7 +512,7 @@ DValue *DtoCastInt(const Loc &loc, DValue *val, Type *_to) {
} else {
rval = new llvm::SIToFPInst(rval, tolltype, "", gIR->scopebb());
}
} else if (to->ty == Tpointer) {
} else if (to->ty == TY::Tpointer) {
IF_LOG Logger::cout() << "cast pointer: " << *tolltype << '\n';
rval = gIR->ir->CreateIntToPtr(rval, tolltype);
} else {
@ -530,18 +530,19 @@ DValue *DtoCastPtr(const Loc &loc, DValue *val, Type *to) {
Type *totype = to->toBasetype();
Type *fromtype = val->type->toBasetype();
(void)fromtype;
assert(fromtype->ty == Tpointer || fromtype->ty == Tfunction);
assert(fromtype->ty == TY::Tpointer || fromtype->ty == TY::Tfunction);
LLValue *rval;
if (totype->ty == Tpointer || totype->ty == Tclass || totype->ty == Taarray) {
if (totype->ty == TY::Tpointer || totype->ty == TY::Tclass ||
totype->ty == TY::Taarray) {
LLValue *src = DtoRVal(val);
IF_LOG {
Logger::cout() << "src: " << *src << '\n';
Logger::cout() << "to type: " << *tolltype << '\n';
}
rval = DtoBitCast(src, tolltype);
} else if (totype->ty == Tbool) {
} else if (totype->ty == TY::Tbool) {
LLValue *src = DtoRVal(val);
LLValue *zero = LLConstant::getNullValue(src->getType());
rval = gIR->ir->CreateICmpNE(src, zero);
@ -572,7 +573,7 @@ DValue *DtoCastFloat(const Loc &loc, DValue *val, Type *to) {
LLValue *rval;
if (totype->ty == Tbool) {
if (totype->ty == TY::Tbool) {
rval = DtoRVal(val);
LLValue *zero = LLConstant::getNullValue(rval->getType());
rval = gIR->ir->CreateFCmpUNE(rval, zero);
@ -607,10 +608,10 @@ DValue *DtoCastFloat(const Loc &loc, DValue *val, Type *to) {
}
DValue *DtoCastDelegate(const Loc &loc, DValue *val, Type *to) {
if (to->toBasetype()->ty == Tdelegate) {
if (to->toBasetype()->ty == TY::Tdelegate) {
return DtoPaintType(loc, val, to);
}
if (to->toBasetype()->ty == Tbool) {
if (to->toBasetype()->ty == TY::Tbool) {
return new DImValue(to,
DtoDelegateEquals(TOKnotequal, DtoRVal(val), nullptr));
}
@ -620,11 +621,11 @@ DValue *DtoCastDelegate(const Loc &loc, DValue *val, Type *to) {
}
DValue *DtoCastVector(const Loc &loc, DValue *val, Type *to) {
assert(val->type->toBasetype()->ty == Tvector);
assert(val->type->toBasetype()->ty == TY::Tvector);
Type *totype = to->toBasetype();
LLType *tolltype = DtoType(to);
if (totype->ty == Tsarray) {
if (totype->ty == TY::Tsarray) {
// Reinterpret-cast without copy if the source vector is in memory.
if (val->isLVal()) {
LLValue *vector = DtoLVal(val);
@ -639,7 +640,7 @@ DValue *DtoCastVector(const Loc &loc, DValue *val, Type *to) {
LLValue *array = DtoAllocaDump(vector, tolltype, DtoAlignment(val->type));
return new DLValue(to, array);
}
if (totype->ty == Tvector && to->size() == val->type->size()) {
if (totype->ty == TY::Tvector && to->size() == val->type->size()) {
return new DImValue(to, DtoBitCast(DtoRVal(val), tolltype));
}
error(loc, "invalid cast from `%s` to `%s`", val->type->toChars(),
@ -649,7 +650,7 @@ DValue *DtoCastVector(const Loc &loc, DValue *val, Type *to) {
DValue *DtoCastStruct(const Loc &loc, DValue *val, Type *to) {
Type *const totype = to->toBasetype();
if (totype->ty == Tstruct) {
if (totype->ty == TY::Tstruct) {
// This a cast to repaint a struct to another type, which the language
// allows for identical layouts (opCast() and so on have been lowered
// earlier by the frontend).
@ -668,8 +669,8 @@ DValue *DtoCast(const Loc &loc, DValue *val, Type *to) {
Type *fromtype = val->type->toBasetype();
Type *totype = to->toBasetype();
if (fromtype->ty == Taarray) {
if (totype->ty == Taarray) {
if (fromtype->ty == TY::Taarray) {
if (totype->ty == TY::Taarray) {
// reinterpret-cast keeping lvalue-ness, IR types will match up
if (val->isLVal())
return new DLValue(to, DtoLVal(val));
@ -677,12 +678,12 @@ DValue *DtoCast(const Loc &loc, DValue *val, Type *to) {
}
// DMD allows casting AAs to void*, even if they are internally
// implemented as structs.
if (totype->ty == Tpointer) {
if (totype->ty == TY::Tpointer) {
IF_LOG Logger::println("Casting AA to pointer.");
LLValue *rval = DtoBitCast(DtoRVal(val), DtoType(to));
return new DImValue(to, rval);
}
if (totype->ty == Tbool) {
if (totype->ty == TY::Tbool) {
IF_LOG Logger::println("Casting AA to bool.");
LLValue *rval = DtoRVal(val);
LLValue *zero = LLConstant::getNullValue(rval->getType());
@ -698,7 +699,7 @@ DValue *DtoCast(const Loc &loc, DValue *val, Type *to) {
to->toChars());
LOG_SCOPE;
if (fromtype->ty == Tvector) {
if (fromtype->ty == TY::Tvector) {
// First, handle vector types (which can also be isintegral()).
return DtoCastVector(loc, val, to);
}
@ -713,20 +714,20 @@ DValue *DtoCast(const Loc &loc, DValue *val, Type *to) {
}
switch (fromtype->ty) {
case Tclass:
case TY::Tclass:
return DtoCastClass(loc, val, to);
case Tarray:
case Tsarray:
case TY::Tarray:
case TY::Tsarray:
return DtoCastArray(loc, val, to);
case Tpointer:
case Tfunction:
case TY::Tpointer:
case TY::Tfunction:
return DtoCastPtr(loc, val, to);
case Tdelegate:
case TY::Tdelegate:
return DtoCastDelegate(loc, val, to);
case Tstruct:
case TY::Tstruct:
return DtoCastStruct(loc, val, to);
case Tnull:
case Tnoreturn:
case TY::Tnull:
case TY::Tnoreturn:
return DtoNullValue(to, loc);
default:
error(loc, "invalid cast from `%s` to `%s`", val->type->toChars(),
@ -742,9 +743,9 @@ DValue *DtoPaintType(const Loc &loc, DValue *val, Type *to) {
IF_LOG Logger::println("repainting from '%s' to '%s'", from->toChars(),
to->toChars());
if (from->ty == Tarray) {
if (from->ty == TY::Tarray) {
Type *at = to->toBasetype();
assert(at->ty == Tarray);
assert(at->ty == TY::Tarray);
Type *elem = at->nextOf()->pointerTo();
if (DSliceValue *slice = val->isSlice()) {
return new DSliceValue(to, slice->getLength(),
@ -761,9 +762,9 @@ DValue *DtoPaintType(const Loc &loc, DValue *val, Type *to) {
ptr = DtoBitCast(ptr, DtoType(elem));
return new DImValue(to, DtoAggrPair(len, ptr));
}
if (from->ty == Tdelegate) {
if (from->ty == TY::Tdelegate) {
Type *dgty = to->toBasetype();
assert(dgty->ty == Tdelegate);
assert(dgty->ty == TY::Tdelegate);
if (val->isLVal()) {
LLValue *ptr = DtoLVal(val);
assert(isaPointer(ptr));
@ -779,14 +780,16 @@ DValue *DtoPaintType(const Loc &loc, DValue *val, Type *to) {
IF_LOG Logger::cout() << "dg: " << *aggr << '\n';
return new DImValue(to, aggr);
}
if (from->ty == Tpointer || from->ty == Tclass || from->ty == Taarray) {
if (from->ty == TY::Tpointer || from->ty == TY::Tclass ||
from->ty == TY::Taarray) {
Type *b = to->toBasetype();
assert(b->ty == Tpointer || b->ty == Tclass || b->ty == Taarray);
assert(b->ty == TY::Tpointer || b->ty == TY::Tclass ||
b->ty == TY::Taarray);
LLValue *ptr = DtoBitCast(DtoRVal(val), DtoType(b));
return new DImValue(to, ptr);
}
if (from->ty == Tsarray) {
assert(to->toBasetype()->ty == Tsarray);
if (from->ty == TY::Tsarray) {
assert(to->toBasetype()->ty == TY::Tsarray);
LLValue *ptr = DtoBitCast(DtoLVal(val), DtoPtrToType(to));
return new DLValue(to, ptr);
}
@ -1128,7 +1131,7 @@ LLConstant *DtoConstExpInit(const Loc &loc, Type *targetType, Expression *exp) {
if (llType == targetLLType)
return val;
if (baseTargetType->ty == Tsarray) {
if (baseTargetType->ty == TY::Tsarray) {
Logger::println("Building constant array initializer from scalar.");
assert(baseValType->size() > 0);
@ -1138,7 +1141,7 @@ LLConstant *DtoConstExpInit(const Loc &loc, Type *targetType, Expression *exp) {
// may be a multi-dimensional array init, e.g., `char[2][3] x = 0xff`
baseValType = stripModifiers(baseValType);
LLSmallVector<size_t, 4> dims; // { 3, 2 }
for (auto t = baseTargetType; t->ty == Tsarray;) {
for (auto t = baseTargetType; t->ty == TY::Tsarray;) {
dims.push_back(static_cast<TypeSArray *>(t)->dim->toUInteger());
auto elementType = stripModifiers(t->nextOf()->toBasetype());
if (elementType->equals(baseValType))
@ -1159,11 +1162,11 @@ LLConstant *DtoConstExpInit(const Loc &loc, Type *targetType, Expression *exp) {
return val;
}
if (baseTargetType->ty == Tvector) {
if (baseTargetType->ty == TY::Tvector) {
Logger::println("Building constant vector initializer from scalar.");
TypeVector *tv = static_cast<TypeVector *>(baseTargetType);
assert(tv->basetype->ty == Tsarray);
assert(tv->basetype->ty == TY::Tsarray);
dinteger_t elemCount =
static_cast<TypeSArray *>(tv->basetype)->dim->toInteger();
#if LDC_LLVM_VER >= 1200
@ -1318,7 +1321,7 @@ size_t getMemberSize(Type *type) {
////////////////////////////////////////////////////////////////////////////////
Type *stripModifiers(Type *type, bool transitive) {
if (type->ty == Tfunction) {
if (type->ty == TY::Tfunction) {
return type;
}
@ -1349,7 +1352,7 @@ void callPostblit(const Loc &loc, Expression *exp, LLValue *val) {
Type *tb = exp->type->toBasetype();
if ((exp->op == TOKvar || exp->op == TOKdotvar || exp->op == TOKstar ||
exp->op == TOKthis || exp->op == TOKindex) &&
tb->ty == Tstruct) {
tb->ty == TY::Tstruct) {
StructDeclaration *sd = static_cast<TypeStruct *>(tb)->sym;
if (sd->postblit) {
FuncDeclaration *fd = sd->postblit;
@ -1359,7 +1362,7 @@ void callPostblit(const Loc &loc, Expression *exp, LLValue *val) {
}
Expressions args;
DFuncValue dfn(fd, DtoCallee(fd), val);
DtoCallFunction(loc, Type::basic[Tvoid], &dfn, &args);
DtoCallFunction(loc, Type::tvoid, &dfn, &args);
}
}
}
@ -1372,7 +1375,9 @@ bool isSpecialRefVar(VarDeclaration *vd) {
////////////////////////////////////////////////////////////////////////////////
bool isLLVMUnsigned(Type *t) { return t->isunsigned() || t->ty == Tpointer; }
bool isLLVMUnsigned(Type *t) {
return t->isunsigned() || t->ty == TY::Tpointer;
}
////////////////////////////////////////////////////////////////////////////////
@ -1527,7 +1532,7 @@ DValue *DtoSymbolAddress(const Loc &loc, Type *type, Declaration *decl) {
}
if (vd->storage_class & STClazy) {
Logger::println("lazy parameter");
assert(type->ty == Tdelegate);
assert(type->ty == TY::Tdelegate);
}
assert(!isSpecialRefVar(vd) && "Code not expected to handle special "
"ref vars, although it can easily be "
@ -1581,8 +1586,8 @@ DValue *DtoSymbolAddress(const Loc &loc, Type *type, Declaration *decl) {
// LDC extension: void[]-typed `__traits(initSymbol)`, for classes too
auto tb = sdecl->type->toBasetype();
if (tb->ty != Tstruct) {
assert(tb->ty == Tarray && tb->nextOf()->ty == Tvoid);
if (tb->ty != TY::Tstruct) {
assert(tb->ty == TY::Tarray && tb->nextOf()->ty == TY::Tvoid);
const auto size = DtoConstSize_t(ad->structsize);
llvm::Constant *ptr =
sd && sd->zeroInit
@ -1896,8 +1901,8 @@ DValue *makeVarDValue(Type *type, VarDeclaration *vd, llvm::Value *storage) {
// The type of globals is determined by their initializer, and the front-end
// may inject implicit casts for class references and static arrays.
assert(vd->isDataseg() || (vd->storage_class & STCextern) ||
type->toBasetype()->ty == Tclass ||
type->toBasetype()->ty == Tsarray);
type->toBasetype()->ty == TY::Tclass ||
type->toBasetype()->ty == TY::Tsarray);
llvm::Type *pointeeType = val->getType()->getPointerElementType();
if (isSpecialRef)
pointeeType = pointeeType->getPointerElementType();

16
gen/naked.cpp
View file

@ -268,8 +268,8 @@ void emitABIReturnAsmStmt(IRAsmBlock *asmblock, const Loc &loc,
// x86
if (triple.getArch() == llvm::Triple::x86) {
if (rt->isintegral() || rt->ty == Tpointer || rt->ty == Tclass ||
rt->ty == Taarray) {
if (rt->isintegral() || rt->ty == TY::Tpointer || rt->ty == TY::Tclass ||
rt->ty == TY::Taarray) {
if (rt->size() == 8) {
as->out_c = "=A,";
} else {
@ -281,7 +281,7 @@ void emitABIReturnAsmStmt(IRAsmBlock *asmblock, const Loc &loc,
// extern(D) always returns on the FPU stack
as->out_c = "={st},={st(1)},";
asmblock->retn = 2;
} else if (rt->ty == Tcomplex32) {
} else if (rt->ty == TY::Tcomplex32) {
// non-extern(D) cfloat is returned as i64
as->out_c = "=A,";
asmblock->retty = LLType::getInt64Ty(gIR->context());
@ -295,7 +295,7 @@ void emitABIReturnAsmStmt(IRAsmBlock *asmblock, const Loc &loc,
} else {
as->out_c = "={st},";
}
} else if (rt->ty == Tarray || rt->ty == Tdelegate) {
} else if (rt->ty == TY::Tarray || rt->ty == TY::Tdelegate) {
as->out_c = "={ax},={dx},";
asmblock->retn = 2;
#if 0
@ -332,8 +332,8 @@ void emitABIReturnAsmStmt(IRAsmBlock *asmblock, const Loc &loc,
// x86_64
else if (triple.getArch() == llvm::Triple::x86_64) {
if (rt->isintegral() || rt->ty == Tpointer || rt->ty == Tclass ||
rt->ty == Taarray) {
if (rt->isintegral() || rt->ty == TY::Tpointer || rt->ty == TY::Tclass ||
rt->ty == TY::Taarray) {
as->out_c = "={ax},";
} else if (rt->isfloating()) {
const bool isWin64 = triple.isOSWindows();
@ -372,7 +372,7 @@ void emitABIReturnAsmStmt(IRAsmBlock *asmblock, const Loc &loc,
// Plain float/double/ifloat/idouble
as->out_c = "={xmm0},";
}
} else if (rt->ty == Tarray || rt->ty == Tdelegate) {
} else if (rt->ty == TY::Tarray || rt->ty == TY::Tdelegate) {
as->out_c = "={ax},={dx},";
asmblock->retn = 2;
} else {
@ -442,7 +442,7 @@ DValue *DtoInlineAsmExpr(const Loc &loc, FuncDeclaration *fd,
DtoInlineAsmExpr(loc, code, constraints, operands, irReturnType);
// work around missing tuple support for users of the return value
if (sretPointer || returnType->ty == Tstruct) {
if (sretPointer || returnType->ty == TY::Tstruct) {
auto lvalue = sretPointer;
if (!lvalue)
lvalue = DtoAlloca(returnType, ".__asm_tuple_ret");

4
gen/pragma.cpp
View file

@ -369,10 +369,10 @@ void DtoCheckPragma(PragmaDeclaration *decl, Dsymbol *s,
case LLVMglobal_crt_dtor: {
const unsigned char flag = llvm_internal == LLVMglobal_crt_ctor ? 1 : 2;
const int count = applyFunctionPragma(s, [=](FuncDeclaration *fd) {
assert(fd->type->ty == Tfunction);
assert(fd->type->ty == TY::Tfunction);
TypeFunction *type = static_cast<TypeFunction *>(fd->type);
Type *retType = type->next;
if (retType->ty != Tvoid || type->parameterList.length() > 0 ||
if (retType->ty != TY::Tvoid || type->parameterList.length() > 0 ||
(fd->isMember() && !fd->isStatic())) {
error(s->loc,
"the `%s` pragma is only allowed on `void` functions which take "

6
gen/semantic-dcompute.cpp
View file

@ -92,12 +92,12 @@ struct DComputeSemanticAnalyser : public StoppableVisitor {
return;
}
if (decl->type->ty == Taarray) {
if (decl->type->ty == TY::Taarray) {
decl->error("associative arrays not allowed in `@compute` code");
stop = true;
}
// includes interfaces
else if (decl->type->ty == Tclass) {
else if (decl->type->ty == TY::Tclass) {
decl->error("interfaces and classes not allowed in `@compute` code");
}
}
@ -112,7 +112,7 @@ struct DComputeSemanticAnalyser : public StoppableVisitor {
// Nogc enforcement.
// No need to check AssocArrayLiteral because AA's are banned anyway
void visit(ArrayLiteralExp *e) override {
if (e->type->ty != Tarray || !e->elements || !e->elements->length)
if (e->type->ty != TY::Tarray || !e->elements || !e->elements->length)
return;
e->error("array literal in `@compute` code not allowed");
stop = true;

7
gen/statements.cpp
View file

@ -193,10 +193,11 @@ public:
if (!stmt->exp) {
// implicitly return 0 for the main function
returnValue = LLConstant::getNullValue(funcType->getReturnType());
} else if ((rtb->ty == Tvoid || rtb->ty == Tnoreturn) && !isMainFunc) {
} else if ((rtb->ty == TY::Tvoid || rtb->ty == TY::Tnoreturn) &&
!isMainFunc) {
// evaluate expression for side effects
assert(stmt->exp->type->toBasetype()->ty == Tvoid ||
stmt->exp->type->toBasetype()->ty == Tnoreturn);
assert(stmt->exp->type->toBasetype()->ty == TY::Tvoid ||
stmt->exp->type->toBasetype()->ty == TY::Tnoreturn);
toElem(stmt->exp);
} else if (funcType->getReturnType()->isVoidTy()) {
// if the IR function's return type is void (but not the D one), it uses

14
gen/structs.cpp
View file

@ -74,7 +74,7 @@ void DtoResolveStruct(StructDeclaration *sd, const Loc &callerLoc) {
LLValue *DtoStructEquals(TOK op, DValue *lhs, DValue *rhs) {
Type *t = lhs->type->toBasetype();
assert(t->ty == Tstruct);
assert(t->ty == TY::Tstruct);
// set predicate
llvm::ICmpInst::Predicate cmpop;
@ -102,7 +102,7 @@ LLValue *DtoStructEquals(TOK op, DValue *lhs, DValue *rhs) {
/// specified type.
/// Union types will get expanded into a struct, with a type for each member.
LLType *DtoUnpaddedStructType(Type *dty) {
assert(dty->ty == Tstruct);
assert(dty->ty == TY::Tstruct);
typedef llvm::DenseMap<Type *, llvm::StructType *> CacheT;
static llvm::ManagedStatic<CacheT> cache;
@ -119,7 +119,7 @@ LLType *DtoUnpaddedStructType(Type *dty) {
for (unsigned i = 0; i < fields.length; i++) {
LLType *fty;
if (fields[i]->type->ty == Tstruct) {
if (fields[i]->type->ty == TY::Tstruct) {
// Nested structs are the only members that can contain padding
fty = DtoUnpaddedStructType(fields[i]->type);
} else {
@ -137,7 +137,7 @@ LLType *DtoUnpaddedStructType(Type *dty) {
/// Note: v must be a pointer to a struct, but the return value will be a
/// first-class struct value.
LLValue *DtoUnpaddedStruct(Type *dty, LLValue *v) {
assert(dty->ty == Tstruct);
assert(dty->ty == TY::Tstruct);
TypeStruct *sty = static_cast<TypeStruct *>(dty);
VarDeclarations &fields = sty->sym->fields;
@ -146,7 +146,7 @@ LLValue *DtoUnpaddedStruct(Type *dty, LLValue *v) {
for (unsigned i = 0; i < fields.length; i++) {
LLValue *fieldptr = DtoIndexAggregate(v, sty->sym, fields[i]);
LLValue *fieldval;
if (fields[i]->type->ty == Tstruct) {
if (fields[i]->type->ty == TY::Tstruct) {
// Nested structs are the only members that can contain padding
fieldval = DtoUnpaddedStruct(fields[i]->type, fieldptr);
} else {
@ -159,14 +159,14 @@ LLValue *DtoUnpaddedStruct(Type *dty, LLValue *v) {
/// Undo the transformation performed by DtoUnpaddedStruct, writing to lval.
void DtoPaddedStruct(Type *dty, LLValue *v, LLValue *lval) {
assert(dty->ty == Tstruct);
assert(dty->ty == TY::Tstruct);
TypeStruct *sty = static_cast<TypeStruct *>(dty);
VarDeclarations &fields = sty->sym->fields;
for (unsigned i = 0; i < fields.length; i++) {
LLValue *fieldptr = DtoIndexAggregate(lval, sty->sym, fields[i]);
LLValue *fieldval = DtoExtractValue(v, i);
if (fields[i]->type->ty == Tstruct) {
if (fields[i]->type->ty == TY::Tstruct) {
// Nested structs are the only members that can contain padding
DtoPaddedStruct(fields[i]->type, fieldval, fieldptr);
} else {

4
gen/target.cpp
View file

@ -181,7 +181,7 @@ void Target::_init(const Param &params) {
*/
unsigned Target::alignsize(Type *type) {
assert(type->isTypeBasic());
if (type->ty == Tvoid) {
if (type->ty == TY::Tvoid) {
return 1;
}
return gDataLayout->getABITypeAlignment(DtoType(type));
@ -207,7 +207,7 @@ Type *Target::va_listType(const Loc &loc, Scope *sc) {
* null if unhandled
*/
const char *TargetCPP::typeMangle(Type *t) {
if (t->ty == Tfloat80) {
if (t->ty == TY::Tfloat80) {
const auto &triple = *global.params.targetTriple;
// `long double` on Android/x64 is __float128 and mangled as `g`
bool isAndroidX64 = triple.getEnvironment() == llvm::Triple::Android &&

36
gen/tocall.cpp
View file

@ -45,10 +45,10 @@ IrFuncTy &DtoIrTypeFunction(DValue *fnval) {
TypeFunction *DtoTypeFunction(DValue *fnval) {
Type *type = fnval->type->toBasetype();
if (type->ty == Tfunction) {
if (type->ty == TY::Tfunction) {
return static_cast<TypeFunction *>(type);
}
if (type->ty == Tdelegate) {
if (type->ty == TY::Tdelegate) {
// FIXME: There is really no reason why the function type should be
// unmerged at this stage, but the frontend still seems to produce such
// cases; for example for the uint(uint) next type of the return type of
@ -63,7 +63,7 @@ TypeFunction *DtoTypeFunction(DValue *fnval) {
// root cause.
Type *next = merge(type->nextOf());
assert(next->ty == Tfunction);
assert(next->ty == TY::Tfunction);
return static_cast<TypeFunction *>(next);
}
@ -74,10 +74,10 @@ TypeFunction *DtoTypeFunction(DValue *fnval) {
LLValue *DtoCallableValue(DValue *fn) {
Type *type = fn->type->toBasetype();
if (type->ty == Tfunction) {
if (type->ty == TY::Tfunction) {
return DtoRVal(fn);
}
if (type->ty == Tdelegate) {
if (type->ty == TY::Tdelegate) {
if (fn->isLVal()) {
LLValue *dg = DtoLVal(fn);
LLValue *funcptr = DtoGEP(dg, 0, 1);
@ -365,7 +365,7 @@ bool DtoLowerMagicIntrinsic(IRState *p, FuncDeclaration *fndecl, CallExp *e,
}
Expression *exp = (*e->arguments)[0];
DValue *expv = toElem(exp);
if (expv->type->toBasetype()->ty != Tint32) {
if (expv->type->toBasetype()->ty != TY::Tint32) {
expv = DtoCast(e->loc, expv, Type::tint32);
}
result = new DImValue(e->type,
@ -472,7 +472,7 @@ bool DtoLowerMagicIntrinsic(IRState *p, FuncDeclaration *fndecl, CallExp *e,
e->error("`cmpxchg` instruction expects 6 arguments");
fatal();
}
if (e->type->ty != Tstruct) {
if (e->type->ty != TY::Tstruct) {
e->error("`cmpxchg` instruction returns a struct");
fatal();
}
@ -660,7 +660,7 @@ public:
: args(args), attrs(attrs), loc(loc), fnval(fnval), argexps(argexps),
resulttype(resulttype), sretPointer(sretPointer),
// computed:
isDelegateCall(fnval->type->toBasetype()->ty == Tdelegate),
isDelegateCall(fnval->type->toBasetype()->ty == TY::Tdelegate),
dfnval(fnval->isFunc()), irFty(DtoIrTypeFunction(fnval)),
tf(DtoTypeFunction(fnval)),
llArgTypesBegin(llCalleeType->param_begin()) {}
@ -904,7 +904,7 @@ DValue *DtoCallFunction(const Loc &loc, Type *resulttype, DValue *fnval,
LLValue *retllval = irFty.arg_sret ? args[sretArgIndex]
: static_cast<llvm::Instruction *>(call);
bool retValIsLVal =
(tf->isref() && returnTy != Tvoid) || (irFty.arg_sret != nullptr);
(tf->isref() && returnTy != TY::Tvoid) || (irFty.arg_sret != nullptr);
if (!retValIsLVal) {
// let the ABI transform the return value back
@ -923,7 +923,7 @@ DValue *DtoCallFunction(const Loc &loc, Type *resulttype, DValue *fnval,
IF_LOG Logger::println("repainting return value from '%s' to '%s'",
returntype->toChars(), rbase->toChars());
switch (rbase->ty) {
case Tarray:
case TY::Tarray:
if (tf->isref()) {
retllval = DtoBitCast(retllval, DtoType(rbase->pointerTo()));
} else {
@ -931,8 +931,8 @@ DValue *DtoCallFunction(const Loc &loc, Type *resulttype, DValue *fnval,
}
break;
case Tsarray:
if (nextbase->ty == Tvector && !tf->isref()) {
case TY::Tsarray:
if (nextbase->ty == TY::Tvector && !tf->isref()) {
if (retValIsLVal) {
retllval = DtoBitCast(retllval, DtoType(rbase->pointerTo()));
} else {
@ -946,9 +946,9 @@ DValue *DtoCallFunction(const Loc &loc, Type *resulttype, DValue *fnval,
}
goto unknownMismatch;
case Tclass:
case Taarray:
case Tpointer:
case TY::Tclass:
case TY::Taarray:
case TY::Tpointer:
if (tf->isref()) {
retllval = DtoBitCast(retllval, DtoType(rbase->pointerTo()));
} else {
@ -956,8 +956,8 @@ DValue *DtoCallFunction(const Loc &loc, Type *resulttype, DValue *fnval,
}
break;
case Tstruct:
if (nextbase->ty == Taarray && !tf->isref()) {
case TY::Tstruct:
if (nextbase->ty == TY::Taarray && !tf->isref()) {
// In the D2 frontend, the associative array type and its
// object.AssociativeArray representation are used
// interchangably in some places. However, AAs are returned
@ -1047,7 +1047,7 @@ DValue *DtoCallFunction(const Loc &loc, Type *resulttype, DValue *fnval,
return new DLValue(resulttype, retllval);
}
if (rbase->ty == Tarray) {
if (rbase->ty == TY::Tarray) {
return new DSliceValue(resulttype, retllval);
}

41
gen/toconstelem.cpp
View file

@ -73,7 +73,7 @@ public:
if (SymbolDeclaration *sdecl = e->var->isSymbolDeclaration()) {
// This is the static initialiser (init symbol) for aggregates.
// Exclude void[]-typed `__traits(initSymbol)` (LDC extension).
if (sdecl->type->toBasetype()->ty == Tstruct) {
if (sdecl->type->toBasetype()->ty == TY::Tstruct) {
const auto sd = sdecl->dsym->isStructDeclaration();
assert(sd);
IF_LOG Logger::print("Sym: sd=%s\n", sd->toChars());
@ -146,7 +146,7 @@ public:
e->type->toChars(), e->toChars());
LOG_SCOPE;
LLType *t = DtoType(e->type);
if (e->type->ty == Tarray) {
if (e->type->ty == TY::Tarray) {
assert(isaStruct(t));
result = llvm::ConstantAggregateZero::get(t);
} else {
@ -172,7 +172,7 @@ public:
Type *const t = e->type->toBasetype();
if (t->ty == Tsarray) {
if (t->ty == TY::Tsarray) {
result = buildStringLiteralConstant(e, false);
return;
}
@ -185,9 +185,9 @@ public:
LLConstant *arrptr = llvm::ConstantExpr::getGetElementPtr(
isaPointer(gvar)->getElementType(), gvar, idxs, true);
if (t->ty == Tpointer) {
if (t->ty == TY::Tpointer) {
result = arrptr;
} else if (t->ty == Tarray) {
} else if (t->ty == TY::Tarray) {
LLConstant *clen =
LLConstantInt::get(DtoSize_t(), e->numberOfCodeUnits(), false);
result = DtoConstSlice(clen, arrptr, e->type);
@ -205,7 +205,7 @@ public:
// add to pointer
Type *t1b = e->e1->type->toBasetype();
if (t1b->ty == Tpointer && e->e2->type->isintegral()) {
if (t1b->ty == TY::Tpointer && e->e2->type->isintegral()) {
llvm::Constant *ptr = toConstElem(e->e1);
dinteger_t idx = undoStrideMul(e->loc, t1b, e->e2->toInteger());
result = llvm::ConstantExpr::getGetElementPtr(
@ -222,7 +222,7 @@ public:
LOG_SCOPE;
Type *t1b = e->e1->type->toBasetype();
if (t1b->ty == Tpointer && e->e2->type->isintegral()) {
if (t1b->ty == TY::Tpointer && e->e2->type->isintegral()) {
llvm::Constant *ptr = toConstElem(e->e1);
dinteger_t idx = undoStrideMul(e->loc, t1b, e->e2->toInteger());
@ -247,7 +247,7 @@ public:
// string literal to dyn array:
// reinterpret the string data as an array, calculate the length
if (e->e1->op == TOKstring && tb->ty == Tarray) {
if (e->e1->op == TOKstring && tb->ty == TY::Tarray) {
#if 0
StringExp *strexp = static_cast<StringExp*>(e1);
size_t datalen = strexp->sz * strexp->len;
@ -262,11 +262,12 @@ public:
result = toConstElem(e->e1);
}
// pointer to pointer
else if (tb->ty == Tpointer && e->e1->type->toBasetype()->ty == Tpointer) {
else if (tb->ty == TY::Tpointer &&
e->e1->type->toBasetype()->ty == TY::Tpointer) {
result = llvm::ConstantExpr::getBitCast(toConstElem(e->e1), lltype);
}
// global variable to pointer
else if (tb->ty == Tpointer && e->e1->op == TOKvar) {
else if (tb->ty == TY::Tpointer && e->e1->op == TOKvar) {
VarDeclaration *vd =
static_cast<VarExp *>(e->e1)->var->isVarDeclaration();
assert(vd);
@ -277,13 +278,13 @@ public:
goto Lerr;
}
Type *type = vd->type->toBasetype();
if (type->ty == Tarray || type->ty == Tdelegate) {
if (type->ty == TY::Tarray || type->ty == TY::Tdelegate) {
LLConstant *idxs[2] = {DtoConstSize_t(0), DtoConstSize_t(1)};
value = llvm::ConstantExpr::getGetElementPtr(
isaPointer(value)->getElementType(), value, idxs, true);
}
result = DtoBitCast(value, DtoType(tb));
} else if (tb->ty == Tclass && e->e1->type->ty == Tclass &&
} else if (tb->ty == TY::Tclass && e->e1->type->ty == TY::Tclass &&
e->e1->op == TOKclassreference) {
auto cd = static_cast<ClassReferenceExp *>(e->e1)->originalClass();
llvm::Constant *instance = toConstElem(e->e1);
@ -373,7 +374,7 @@ public:
assert(vexp);
VarDeclaration *vd = vexp->var->isVarDeclaration();
assert(vd);
assert(vd->type->toBasetype()->ty == Tsarray);
assert(vd->type->toBasetype()->ty == TY::Tsarray);
DtoResolveVariable(vd);
assert(isIrGlobalCreated(vd));
@ -389,7 +390,7 @@ public:
isaPointer(val)->getElementType(), val, idxs, true);
// bitcast to requested type
assert(e->type->toBasetype()->ty == Tpointer);
assert(e->type->toBasetype()->ty == TY::Tpointer);
result = DtoBitCast(gep, DtoType(e->type));
return;
}
@ -434,7 +435,7 @@ public:
FuncLiteralDeclaration *fd = e->fd;
assert(fd);
if (fd->tok == TOKreserved && e->type->ty == Tpointer) {
if (fd->tok == TOKreserved && e->type->ty == TY::Tpointer) {
// This is a lambda that was inferred to be a function literal instead
// of a delegate, so set tok here in order to get correct types/mangling.
// Horrible hack, but DMD does the same thing in FuncExp::toElem and
@ -487,7 +488,7 @@ public:
LLArrayType::get(DtoMemType(elemt), e->elements->length);
// dynamic arrays can occur here as well ...
bool dyn = (bt->ty != Tsarray);
bool dyn = (bt->ty != TY::Tsarray);
llvm::Constant *initval = arrayLiteralToConst(p, e);
@ -505,7 +506,7 @@ public:
: llvm::GlobalValue::UnnamedAddr::None);
llvm::Constant *store = DtoBitCast(gvar, getPtrToType(arrtype));
if (bt->ty == Tpointer) {
if (bt->ty == TY::Tpointer) {
// we need to return pointer to the static array.
result = store;
return;
@ -612,7 +613,7 @@ public:
result = constValue;
}
if (e->type->ty == Tclass) {
if (e->type->ty == TY::Tclass) {
ClassDeclaration *targetClass = static_cast<TypeClass *>(e->type)->sym;
if (InterfaceDeclaration *it = targetClass->isInterfaceDeclaration()) {
assert(it->isBaseOf(origClass, NULL));
@ -627,7 +628,7 @@ public:
}
}
assert(e->type->ty == Tclass || e->type->ty == Tenum);
assert(e->type->ty == TY::Tclass || e->type->ty == TY::Tenum);
result = DtoBitCast(result, DtoType(e->type));
}
@ -639,7 +640,7 @@ public:
LOG_SCOPE;
TypeVector *tv = static_cast<TypeVector *>(e->to->toBasetype());
assert(tv->ty == Tvector);
assert(tv->ty == TY::Tvector);
const auto elemCount =
static_cast<TypeSArray *>(tv->basetype)->dim->toInteger();

156
gen/toir.cpp
View file

@ -236,7 +236,7 @@ public:
// Thus, dump the result to a temporary stack slot (created in the entry
// bb) if it is not guaranteed to dominate the end bb after possibly
// adding more control flow.
if (result && result->type->ty != Tvoid &&
if (result && result->type->ty != TY::Tvoid &&
!result->definedInFuncEntryBB()) {
if (result->isRVal()) {
LLValue *lval = DtoAllocaDump(result, ".toElemRValResult");
@ -354,13 +354,13 @@ public:
switch (e->type->toBasetype()->ty) {
default:
llvm_unreachable("Unexpected complex floating point type");
case Tcomplex32:
case TY::Tcomplex32:
c = DtoConstFP(Type::tfloat32, ldouble(0));
break;
case Tcomplex64:
case TY::Tcomplex64:
c = DtoConstFP(Type::tfloat64, ldouble(0));
break;
case Tcomplex80:
case TY::Tcomplex80:
c = DtoConstFP(Type::tfloat80, ldouble(0));
break;
}
@ -391,17 +391,17 @@ public:
LLConstant *arrptr = llvm::ConstantExpr::getGetElementPtr(
isaPointer(gvar)->getElementType(), gvar, idxs, true);
if (dtype->ty == Tarray) {
if (dtype->ty == TY::Tarray) {
LLConstant *clen =
LLConstantInt::get(DtoSize_t(), e->numberOfCodeUnits(), false);
result = new DSliceValue(e->type, DtoConstSlice(clen, arrptr, dtype));
} else if (dtype->ty == Tsarray) {
} else if (dtype->ty == TY::Tsarray) {
LLType *dstType =
getPtrToType(LLArrayType::get(ct, e->numberOfCodeUnits()));
LLValue *emem =
(gvar->getType() == dstType) ? gvar : DtoBitCast(gvar, dstType);
result = new DLValue(e->type, emem);
} else if (dtype->ty == Tpointer) {
} else if (dtype->ty == TY::Tpointer) {
result = new DImValue(e->type, arrptr);
} else {
llvm_unreachable("Unknown type for StringExp.");
@ -463,7 +463,7 @@ public:
DValue *rewrittenLhsStaticArray = nullptr;
if (auto se = e->e1->isSliceExp()) {
Type *sliceeBaseType = se->e1->type->toBasetype();
if (se->lwr == nullptr && sliceeBaseType->ty == Tsarray &&
if (se->lwr == nullptr && sliceeBaseType->ty == TY::Tsarray &&
se->type->toBasetype()->nextOf() == sliceeBaseType->nextOf())
rewrittenLhsStaticArray = toElem(se->e1, true);
}
@ -513,7 +513,7 @@ public:
DValue *r = toElem(e->e2);
if (e->e1->type->toBasetype()->ty == Tstruct && e->e2->op == TOKint64) {
if (e->e1->type->toBasetype()->ty == TY::Tstruct && e->e2->op == TOKint64) {
Logger::println("performing aggregate zero initialization");
assert(e->e2->toInteger() == 0);
LLValue *lval = DtoLVal(lhs);
@ -548,8 +548,8 @@ public:
Type *t2 = e2->type->toBasetype();
// valid array ops would have been transformed by optimize
if ((t1->ty == Tarray || t1->ty == Tsarray) &&
(t2->ty == Tarray || t2->ty == Tsarray)) {
if ((t1->ty == TY::Tarray || t1->ty == TY::Tsarray) &&
(t2->ty == TY::Tarray || t2->ty == TY::Tsarray)) {
base->error("Array operation `%s` not recognized", base->toChars());
fatal();
}
@ -710,7 +710,7 @@ public:
FuncDeclaration *fdecl = dve->var->isFuncDeclaration();
assert(fdecl);
Expression *thisExp = dve->e1;
LLValue *thisArg = thisExp->type->toBasetype()->ty == Tclass
LLValue *thisArg = thisExp->type->toBasetype()->ty == TY::Tclass
? DtoRVal(thisExp)
: DtoLVal(thisExp); // when calling a struct method
fnval = new DFuncValue(fdecl, DtoCallee(fdecl), thisArg);
@ -901,7 +901,7 @@ public:
PGO.setCurrentStmt(e);
// function pointers are special
if (e->type->toBasetype()->ty == Tfunction) {
if (e->type->toBasetype()->ty == TY::Tfunction) {
DValue *dv = toElem(e->e1);
LLValue *llVal = DtoRVal(dv);
if (DFuncValue *dfv = dv->isFunc()) {
@ -938,18 +938,18 @@ public:
if (VarDeclaration *vd = e->var->isVarDeclaration()) {
LLValue *arrptr;
// indexing struct pointer
if (e1type->ty == Tpointer) {
assert(e1type->nextOf()->ty == Tstruct);
if (e1type->ty == TY::Tpointer) {
assert(e1type->nextOf()->ty == TY::Tstruct);
TypeStruct *ts = static_cast<TypeStruct *>(e1type->nextOf());
arrptr = DtoIndexAggregate(DtoRVal(l), ts->sym, vd);
}
// indexing normal struct
else if (e1type->ty == Tstruct) {
else if (e1type->ty == TY::Tstruct) {
TypeStruct *ts = static_cast<TypeStruct *>(e1type);
arrptr = DtoIndexAggregate(DtoLVal(l), ts->sym, vd);
}
// indexing class
else if (e1type->ty == Tclass) {
else if (e1type->ty == TY::Tclass) {
TypeClass *tc = static_cast<TypeClass *>(e1type);
arrptr = DtoIndexAggregate(DtoRVal(l), tc->sym, vd);
} else {
@ -1027,7 +1027,8 @@ public:
result = new DLValue(e->type, DtoBitCast(v, DtoPtrToType(e->type)));
} else if (vd->toParent2() != p->func()->decl) {
Logger::println("nested this exp");
result = DtoNestedVariable(e->loc, e->type, vd, e->type->ty == Tstruct);
result =
DtoNestedVariable(e->loc, e->type, vd, e->type->ty == TY::Tstruct);
} else {
Logger::println("normal this exp");
LLValue *v = p->func()->thisArg;
@ -1054,19 +1055,19 @@ public:
p->arrays.pop_back();
LLValue *arrptr = nullptr;
if (e1type->ty == Tpointer) {
if (e1type->ty == TY::Tpointer) {
arrptr = DtoGEP1(DtoRVal(l), DtoRVal(r));
} else if (e1type->ty == Tsarray) {
} else if (e1type->ty == TY::Tsarray) {
if (p->emitArrayBoundsChecks() && !e->indexIsInBounds) {
DtoIndexBoundsCheck(e->loc, l, r);
}
arrptr = DtoGEP(DtoLVal(l), DtoConstUint(0), DtoRVal(r));
} else if (e1type->ty == Tarray) {
} else if (e1type->ty == TY::Tarray) {
if (p->emitArrayBoundsChecks() && !e->indexIsInBounds) {
DtoIndexBoundsCheck(e->loc, l, r);
}
arrptr = DtoGEP1(DtoArrayPtr(l), DtoRVal(r));
} else if (e1type->ty == Taarray) {
} else if (e1type->ty == TY::Taarray) {
result = DtoAAIndex(e->loc, e->type, l, r, e->modifiable);
return;
} else {
@ -1095,7 +1096,7 @@ public:
// potential bounds have been evaluated
DValue *v = toElem(e->e1);
auto getBasePointer = [v, etype]() {
if (etype->ty == Tpointer) {
if (etype->ty == TY::Tpointer) {
// pointer slicing
return DtoRVal(v);
} else {
@ -1120,7 +1121,7 @@ public:
p->arrays.pop_back();
const bool needCheckUpper =
(etype->ty != Tpointer) && !e->upperIsInBounds;
(etype->ty != TY::Tpointer) && !e->upperIsInBounds;
const bool needCheckLower = !e->lowerIsLessThanUpper;
if (p->emitArrayBoundsChecks() && (needCheckUpper || needCheckLower)) {
llvm::BasicBlock *okbb = p->insertBB("bounds.ok");
@ -1158,13 +1159,13 @@ public:
}
// no bounds or full slice -> just convert to slice
else {
assert(etype->ty != Tpointer);
assert(etype->ty != TY::Tpointer);
eptr = getBasePointer();
// if the slicee is a static array, we use the length of that as DMD seems
// to give contrary inconsistent sizesin some multidimensional static
// array cases.
// (namely default initialization, int[16][16] arr; -> int[256] arr = 0;)
if (etype->ty == Tsarray) {
if (etype->ty == TY::Tsarray) {
TypeSArray *tsa = static_cast<TypeSArray *>(etype);
elen = DtoConstSize_t(tsa->dim->toUInteger());
@ -1177,12 +1178,12 @@ public:
// The frontend generates a SliceExp of static array type when assigning a
// fixed-width slice to a static array.
Type *const ety = e->type->toBasetype();
if (ety->ty == Tsarray) {
if (ety->ty == TY::Tsarray) {
result = new DLValue(e->type, DtoBitCast(eptr, DtoPtrToType(e->type)));
return;
}
assert(ety->ty == Tarray);
assert(ety->ty == TY::Tarray);
if (!elen)
elen = DtoArrayLen(v);
eptr = DtoBitCast(eptr, DtoPtrToType(ety->nextOf()));
@ -1207,7 +1208,7 @@ public:
LLValue *eval = nullptr;
if (t->isintegral() || t->ty == Tpointer || t->ty == Tnull) {
if (t->isintegral() || t->ty == TY::Tpointer || t->ty == TY::Tnull) {
llvm::ICmpInst::Predicate icmpPred;
tokToICmpPred(e->op, isLLVMUnsigned(t), &icmpPred, &eval);
@ -1243,9 +1244,9 @@ public:
llvm_unreachable("Unsupported floating point comparison operator.");
}
eval = p->ir->CreateFCmp(cmpop, DtoRVal(l), DtoRVal(r));
} else if (t->ty == Taarray) {
} else if (t->ty == TY::Taarray) {
eval = LLConstantInt::getFalse(gIR->context());
} else if (t->ty == Tdelegate) {
} else if (t->ty == TY::Tdelegate) {
llvm::ICmpInst::Predicate icmpPred;
tokToICmpPred(e->op, isLLVMUnsigned(t), &icmpPred, &eval);
@ -1310,8 +1311,8 @@ public:
// the Tclass catches interface comparisons, regular
// class equality should be rewritten as a.opEquals(b) by this time
if (t->isintegral() || t->ty == Tpointer || t->ty == Tclass ||
t->ty == Tnull) {
if (t->isintegral() || t->ty == TY::Tpointer || t->ty == TY::Tclass ||
t->ty == TY::Tnull) {
Logger::println("integral or pointer or interface");
llvm::ICmpInst::Predicate cmpop;
switch (e->op) {
@ -1334,22 +1335,22 @@ public:
Logger::cout() << "rv: " << *rv << '\n';
}
eval = p->ir->CreateICmp(cmpop, lv, rv);
if (t->ty == Tvector) {
if (t->ty == TY::Tvector) {
eval = mergeVectorEquals(eval, e->op);
}
} else if (t->isfloating()) // includes iscomplex
{
eval = DtoBinNumericEquals(e->loc, l, r, e->op);
} else if (t->ty == Tsarray || t->ty == Tarray) {
} else if (t->ty == TY::Tsarray || t->ty == TY::Tarray) {
Logger::println("static or dynamic array");
eval = DtoArrayEquals(e->loc, e->op, l, r);
} else if (t->ty == Taarray) {
} else if (t->ty == TY::Taarray) {
Logger::println("associative array");
eval = DtoAAEquals(e->loc, e->op, l, r);
} else if (t->ty == Tdelegate) {
} else if (t->ty == TY::Tdelegate) {
Logger::println("delegate");
eval = DtoDelegateEquals(e->op, DtoRVal(l), DtoRVal(r));
} else if (t->ty == Tstruct) {
} else if (t->ty == TY::Tstruct) {
Logger::println("struct");
// when this is reached it means there is no opEquals overload.
eval = DtoStructEquals(e->op, l, r);
@ -1389,7 +1390,7 @@ public:
} else if (e->op == TOKminusminus) {
post = llvm::BinaryOperator::CreateSub(val, one, "", p->scopebb());
}
} else if (e1type->ty == Tpointer) {
} else if (e1type->ty == TY::Tpointer) {
assert(e->e2->op == TOKint64);
LLConstant *offset =
e->op == TOKplusplus ? DtoConstUint(1) : DtoConstInt(-1);
@ -1441,13 +1442,13 @@ public:
Type *ntype = e->newtype->toBasetype();
// new class
if (ntype->ty == Tclass) {
if (ntype->ty == TY::Tclass) {
Logger::println("new class");
result = DtoNewClass(e->loc, static_cast<TypeClass *>(ntype), e);
isArgprefixHandled = true; // by DtoNewClass()
}
// new dynamic array
else if (ntype->ty == Tarray) {
else if (ntype->ty == TY::Tarray) {
IF_LOG Logger::println("new dynamic array: %s", e->newtype->toChars());
assert(e->argprefix == NULL);
// get dim
@ -1468,11 +1469,11 @@ public:
}
}
// new static array
else if (ntype->ty == Tsarray) {
else if (ntype->ty == TY::Tsarray) {
llvm_unreachable("Static array new should decay to dynamic array.");
}
// new struct
else if (ntype->ty == Tstruct) {
else if (ntype->ty == TY::Tstruct) {
IF_LOG Logger::println("new struct on heap: %s\n", e->newtype->toChars());
TypeStruct *ts = static_cast<TypeStruct *>(ntype);
@ -1562,16 +1563,16 @@ public:
Type *et = e->e1->type->toBasetype();
// pointer
if (et->ty == Tpointer) {
if (et->ty == TY::Tpointer) {
Type *elementType = et->nextOf()->toBasetype();
if (elementType->ty == Tstruct && elementType->needsDestruction()) {
if (elementType->ty == TY::Tstruct && elementType->needsDestruction()) {
DtoDeleteStruct(e->loc, dval);
} else {
DtoDeleteMemory(e->loc, dval);
}
}
// class
else if (et->ty == Tclass) {
else if (et->ty == TY::Tclass) {
bool onstack = false;
TypeClass *tc = static_cast<TypeClass *>(et);
if (tc->sym->isInterfaceDeclaration()) {
@ -1595,7 +1596,7 @@ public:
}
}
// dyn array
else if (et->ty == Tarray) {
else if (et->ty == TY::Tarray) {
DtoDeleteArray(e->loc, dval);
if (dval->isLVal()) {
DtoSetArrayToNull(DtoLVal(dval));
@ -1698,7 +1699,8 @@ public:
DtoBitCast(DtoRVal(cond), fn->getFunctionType()->getParamType(0));
gIR->CreateCallOrInvoke(fn, arg);
} else if (condty->ty == Tpointer && condty->nextOf()->ty == Tstruct) {
} else if (condty->ty == TY::Tpointer &&
condty->nextOf()->ty == TY::Tstruct) {
const auto invDecl =
static_cast<TypeStruct *>(condty->nextOf())->sym->inv;
if (!invDecl)
@ -1778,7 +1780,7 @@ public:
p->ir->SetInsertPoint(endBB);
// DMD allows stuff like `x == 0 && assert(false)`
if (e->type->toBasetype()->ty == Tvoid) {
if (e->type->toBasetype()->ty == TY::Tvoid) {
result = nullptr;
return;
}
@ -1838,7 +1840,7 @@ public:
LLPointerType *int8ptrty = getPtrToType(LLType::getInt8Ty(gIR->context()));
assert(e->type->toBasetype()->ty == Tdelegate);
assert(e->type->toBasetype()->ty == TY::Tdelegate);
LLType *dgty = DtoType(e->type);
DValue *u = toElem(e->e1);
@ -1903,12 +1905,12 @@ public:
Type *t1 = e->e1->type->toBasetype();
// handle dynarray specially
if (t1->ty == Tarray) {
if (t1->ty == TY::Tarray) {
result = new DImValue(e->type, DtoDynArrayIs(e->op, l, r));
return;
}
// also structs
if (t1->ty == Tstruct) {
if (t1->ty == TY::Tstruct) {
result = new DImValue(e->type, DtoStructEquals(e->op, l, r));
return;
}
@ -1916,7 +1918,7 @@ public:
// FIXME this stuff isn't pretty
LLValue *eval = nullptr;
if (t1->ty == Tdelegate) {
if (t1->ty == TY::Tdelegate) {
LLValue *lv = DtoRVal(l);
LLValue *rv = nullptr;
if (!r->isNull()) {
@ -1927,7 +1929,7 @@ public:
} else if (t1->isfloating()) // includes iscomplex
{
eval = DtoBinNumericEquals(e->loc, l, r, e->op);
} else if (t1->ty == Tpointer || t1->ty == Tclass) {
} else if (t1->ty == TY::Tpointer || t1->ty == TY::Tclass) {
LLValue *lv = DtoRVal(l);
LLValue *rv = DtoRVal(r);
if (lv->getType() != rv->getType()) {
@ -1939,7 +1941,7 @@ public:
}
eval = (e->op == TOKidentity) ? p->ir->CreateICmpEQ(lv, rv)
: p->ir->CreateICmpNE(lv, rv);
} else if (t1->ty == Tsarray) {
} else if (t1->ty == TY::Tsarray) {
LLValue *lptr = DtoLVal(l);
LLValue *rptr = DtoLVal(r);
assert(lptr->getType() == rptr->getType());
@ -1951,7 +1953,7 @@ public:
assert(lv->getType() == rv->getType());
eval = (e->op == TOKidentity) ? p->ir->CreateICmpEQ(lv, rv)
: p->ir->CreateICmpNE(lv, rv);
if (t1->ty == Tvector) {
if (t1->ty == TY::Tvector) {
eval = mergeVectorEquals(eval,
e->op == TOKidentity ? TOKequal : TOKnotequal);
}
@ -1985,7 +1987,7 @@ public:
Type *dtype = e->type->toBasetype();
LLValue *retPtr = nullptr;
if (!(dtype->ty == Tvoid || dtype->ty == Tnoreturn)) {
if (!(dtype->ty == TY::Tvoid || dtype->ty == TY::Tnoreturn)) {
// allocate a temporary for pointer to the final result.
retPtr = DtoAlloca(dtype->pointerTo(), "condtmp");
}
@ -2005,7 +2007,7 @@ public:
p->ir->SetInsertPoint(condtrue);
PGO.emitCounterIncrement(e);
DValue *u = toElem(e->e1);
if (retPtr && u->type->toBasetype()->ty != Tnoreturn) {
if (retPtr && u->type->toBasetype()->ty != TY::Tnoreturn) {
LLValue *lval = makeLValue(e->loc, u);
DtoStore(lval, DtoBitCast(retPtr, lval->getType()->getPointerTo()));
}
@ -2013,7 +2015,7 @@ public:
p->ir->SetInsertPoint(condfalse);
DValue *v = toElem(e->e2);
if (retPtr && v->type->toBasetype()->ty != Tnoreturn) {
if (retPtr && v->type->toBasetype()->ty != TY::Tnoreturn) {
LLValue *lval = makeLValue(e->loc, v);
DtoStore(lval, DtoBitCast(retPtr, lval->getType()->getPointerTo()));
}
@ -2096,16 +2098,16 @@ public:
result = toElem(e->e1);
Type *e1type = e->e1->type->toBasetype();
assert(e1type->ty == Tarray);
assert(e1type->ty == TY::Tarray);
Type *elemtype = e1type->nextOf()->toBasetype();
Type *e2type = e->e2->type->toBasetype();
if (e1type->ty == Tarray && e2type->ty == Tdchar &&
(elemtype->ty == Tchar || elemtype->ty == Twchar)) {
if (elemtype->ty == Tchar) {
if (e1type->ty == TY::Tarray && e2type->ty == TY::Tdchar &&
(elemtype->ty == TY::Tchar || elemtype->ty == TY::Twchar)) {
if (elemtype->ty == TY::Tchar) {
// append dchar to char[]
DtoAppendDCharToString(e->loc, result, e->e2);
} else { /*if (elemtype->ty == Twchar)*/
} else { /*if (elemtype->ty == TY::Twchar)*/
// append dchar to wchar[]
DtoAppendDCharToUnicodeString(e->loc, result, e->e2);
}
@ -2123,7 +2125,7 @@ public:
void genFuncLiteral(FuncLiteralDeclaration *fd, FuncExp *e) {
if ((fd->tok == TOKreserved || fd->tok == TOKdelegate) &&
(e && e->type->ty == Tpointer)) {
(e && e->type->ty == TY::Tpointer)) {
// This is a lambda that was inferred to be a function literal instead
// of a delegate, so set tok here in order to get correct types/mangling.
// Horrible hack, but DMD does the same thing.
@ -2187,7 +2189,7 @@ public:
Type *elemType = arrayType->nextOf()->toBasetype();
// is dynamic ?
bool const dyn = (arrayType->ty == Tarray);
bool const dyn = (arrayType->ty == TY::Tarray);
// length
size_t const len = e->elements->length;
@ -2228,9 +2230,9 @@ public:
llvm::Value *storage =
DtoRawAlloca(llStoType, DtoAlignment(e->type), "arrayliteral");
initializeArrayLiteral(p, e, storage);
if (arrayType->ty == Tsarray) {
if (arrayType->ty == TY::Tsarray) {
result = new DLValue(e->type, storage);
} else if (arrayType->ty == Tpointer) {
} else if (arrayType->ty == TY::Tpointer) {
storage = DtoBitCast(storage, llElemType->getPointerTo());
result = new DImValue(e->type, storage);
} else {
@ -2366,7 +2368,7 @@ public:
goto LruntimeInit;
}
if (aatype->ty != Taarray) {
if (aatype->ty != TY::Taarray) {
// It's the AssociativeArray type.
// Turn it back into a TypeAArray
vtype = e->values->tdata()[0]->type;
@ -2395,7 +2397,7 @@ public:
valuesInits.push_back(evalConst);
}
assert(aatype->ty == Taarray);
assert(aatype->ty == TY::Taarray);
Type *indexType = static_cast<TypeAArray *>(aatype)->index;
assert(indexType && vtype);
@ -2428,7 +2430,7 @@ public:
LLValue *aa = gIR->CreateCallOrInvoke(func, aaTypeInfo, keysArray,
valuesArray, "aa");
if (basetype->ty != Taarray) {
if (basetype->ty != TY::Taarray) {
LLValue *tmp = DtoAlloca(e->type, "aaliteral");
DtoStore(aa, DtoGEP(tmp, 0u, 0));
result = new DLValue(e->type, tmp);
@ -2534,7 +2536,7 @@ public:
LLValue *gep = DtoGEP(val, 0, i);
if (DtoIsInMemoryOnly(el->type)) {
DtoMemCpy(gep, DtoLVal(ep));
} else if (el->type->ty != Tvoid) {
} else if (el->type->ty != TY::Tvoid) {
DtoStoreZextI8(DtoRVal(ep), gep);
} else {
DtoStore(LLConstantInt::get(LLType::getInt8Ty(p->context()), 0, false),
@ -2553,7 +2555,7 @@ public:
const unsigned N = e->dim;
Type *elementType = type->elementType();
if (elementType->ty == Tvoid)
if (elementType->ty == TY::Tvoid)
elementType = Type::tuns8;
const auto getCastElement = [e, elementType](DValue *element) {
@ -2590,7 +2592,7 @@ public:
DtoStore(llElements[i], DtoGEP(dstMem, 0, i));
}
}
} else if (tsrc->ty == Tarray || tsrc->ty == Tsarray) {
} else if (tsrc->ty == TY::Tarray || tsrc->ty == TY::Tsarray) {
// Arrays: prefer a memcpy if the LL element types match, otherwise cast
// and store element-wise.
if (auto ts = tsrc->isTypeSArray()) {
@ -2678,7 +2680,7 @@ public:
}
if (Expression *ex = isExpression(e->obj)) {
Type *t = ex->type->toBasetype();
assert(t->ty == Tclass);
assert(t->ty == TY::Tclass);
LLValue *val = DtoRVal(ex);
@ -2768,7 +2770,7 @@ bool toInPlaceConstruction(DLValue *lhs, Expression *rhs) {
if (auto ve = rhs->isVarExp()) {
if (auto symdecl = ve->var->isSymbolDeclaration()) {
// exclude void[]-typed `__traits(initSymbol)` (LDC extension)
if (symdecl->type->toBasetype()->ty == Tstruct) {
if (symdecl->type->toBasetype()->ty == TY::Tstruct) {
auto sd = symdecl->dsym->isStructDeclaration();
assert(sd);
DtoResolveStruct(sd);
@ -2826,7 +2828,7 @@ bool toInPlaceConstruction(DLValue *lhs, Expression *rhs) {
}
// and static array literals
else if (auto al = rhs->isArrayLiteralExp()) {
if (lhs->type->toBasetype()->ty == Tsarray) {
if (lhs->type->toBasetype()->ty == TY::Tsarray) {
Logger::println("success, in-place-constructing array literal");
initializeArrayLiteral(gIR, al, DtoLVal(lhs));
return true;

84
gen/tollvm.cpp
View file

@ -42,12 +42,12 @@
bool DtoIsInMemoryOnly(Type *type) {
Type *typ = type->toBasetype();
TY t = typ->ty;
return (t == Tstruct || t == Tsarray);
return (t == TY::Tstruct || t == TY::Tsarray);
}
bool DtoIsReturnInArg(CallExp *ce) {
Type *t = ce->e1->type->toBasetype();
if (t->ty == Tfunction && (!ce->f || !DtoIsIntrinsic(ce->f))) {
if (t->ty == TY::Tfunction && (!ce->f || !DtoIsIntrinsic(ce->f))) {
return gABI->returnInArg(static_cast<TypeFunction *>(t),
ce->f && ce->f->needThis());
}
@ -56,7 +56,7 @@ bool DtoIsReturnInArg(CallExp *ce) {
void DtoAddExtendAttr(Type *type, llvm::AttrBuilder &attrs) {
type = type->toBasetype();
if (type->isintegral() && type->ty != Tvector && type->size() <= 2) {
if (type->isintegral() && type->ty != TY::Tvector && type->size() <= 2) {
attrs.addAttribute(type->isunsigned() ? LLAttribute::ZExt
: LLAttribute::SExt);
}
@ -74,61 +74,61 @@ LLType *DtoType(Type *t) {
switch (t->ty) {
// basic types
case Tvoid:
case Tint8:
case Tuns8:
case Tint16:
case Tuns16:
case Tint32:
case Tuns32:
case Tint64:
case Tuns64:
case Tint128:
case Tuns128:
case Tfloat32:
case Tfloat64:
case Tfloat80:
case Timaginary32:
case Timaginary64:
case Timaginary80:
case Tcomplex32:
case Tcomplex64:
case Tcomplex80:
// case Tbit:
case Tbool:
case Tchar:
case Twchar:
case Tdchar:
case Tnoreturn: {
case TY::Tvoid:
case TY::Tint8:
case TY::Tuns8:
case TY::Tint16:
case TY::Tuns16:
case TY::Tint32:
case TY::Tuns32:
case TY::Tint64:
case TY::Tuns64:
case TY::Tint128:
case TY::Tuns128:
case TY::Tfloat32:
case TY::Tfloat64:
case TY::Tfloat80:
case TY::Timaginary32:
case TY::Timaginary64:
case TY::Timaginary80:
case TY::Tcomplex32:
case TY::Tcomplex64:
case TY::Tcomplex80:
// case TY::Tbit:
case TY::Tbool:
case TY::Tchar:
case TY::Twchar:
case TY::Tdchar:
case TY::Tnoreturn: {
return IrTypeBasic::get(t)->getLLType();
}
// pointers
case Tnull:
case Tpointer: {
case TY::Tnull:
case TY::Tpointer: {
return IrTypePointer::get(t)->getLLType();
}
// arrays
case Tarray: {
case TY::Tarray: {
return IrTypeArray::get(t)->getLLType();
}
case Tsarray: {
case TY::Tsarray: {
return IrTypeSArray::get(t)->getLLType();
}
// aggregates
case Tstruct:
case Tclass: {
const auto isStruct = t->ty == Tstruct;
case TY::Tstruct:
case TY::Tclass: {
const auto isStruct = t->ty == TY::Tstruct;
AggregateDeclaration *ad;
if (isStruct) {
ad = static_cast<TypeStruct *>(t)->sym;
} else {
ad = static_cast<TypeClass *>(t)->sym;
}
if (ad->type->ty == Terror) {
if (ad->type->ty == TY::Terror) {
static LLStructType *opaqueErrorType =
LLStructType::create(gIR->context(), Type::terror->toChars());
return opaqueErrorType;
@ -158,12 +158,12 @@ LLType *DtoType(Type *t) {
}
// functions
case Tfunction: {
case TY::Tfunction: {
return IrTypeFunction::get(t)->getLLType();
}
// delegates
case Tdelegate: {
case TY::Tdelegate: {
return IrTypeDelegate::get(t)->getLLType();
}
@ -171,7 +171,7 @@ LLType *DtoType(Type *t) {
// enum
// FIXME: maybe just call toBasetype first ?
case Tenum: {
case TY::Tenum: {
Type *bt = t->toBasetype();
assert(bt);
if (t == bt) {
@ -184,10 +184,10 @@ LLType *DtoType(Type *t) {
}
// associative arrays
case Taarray:
case TY::Taarray:
return getVoidPtrType();
case Tvector:
case TY::Tvector:
return IrTypeVector::get(t)->getLLType();
default:

16
gen/typinf.cpp
View file

@ -82,8 +82,8 @@ void emitTypeInfoMetadata(LLGlobalVariable *typeinfoGlobal, Type *forType) {
// As those types cannot appear as LLVM values, they are not interesting for
// the optimizer passes anyway.
Type *t = forType->toBasetype();
if (t->ty < Terror && t->ty != Tvoid && t->ty != Tfunction &&
t->ty != Tident) {
if (t->ty < TY::Terror && t->ty != TY::Tvoid && t->ty != TY::Tfunction &&
t->ty != TY::Tident) {
const auto metaname = getMetadataName(TD_PREFIX, typeinfoGlobal);
if (!gIR->module.getNamedMetadata(metaname)) {
@ -129,7 +129,7 @@ public:
RTTIBuilder b(getEnumTypeInfoType());
assert(decl->tinfo->ty == Tenum);
assert(decl->tinfo->ty == TY::Tenum);
TypeEnum *tc = static_cast<TypeEnum *>(decl->tinfo);
EnumDeclaration *sd = tc->sym;
@ -190,7 +190,7 @@ public:
decl->toChars());
LOG_SCOPE;
assert(decl->tinfo->ty == Tsarray);
assert(decl->tinfo->ty == TY::Tsarray);
TypeSArray *tc = static_cast<TypeSArray *>(decl->tinfo);
RTTIBuilder b(getStaticArrayTypeInfoType());
@ -213,7 +213,7 @@ public:
decl->toChars());
LOG_SCOPE;
assert(decl->tinfo->ty == Taarray);
assert(decl->tinfo->ty == TY::Taarray);
TypeAArray *tc = static_cast<TypeAArray *>(decl->tinfo);
RTTIBuilder b(getAssociativeArrayTypeInfoType());
@ -251,7 +251,7 @@ public:
decl->toChars());
LOG_SCOPE;
assert(decl->tinfo->ty == Tdelegate);
assert(decl->tinfo->ty == TY::Tdelegate);
Type *ret_type = decl->tinfo->nextOf()->nextOf();
RTTIBuilder b(getDelegateTypeInfoType());
@ -303,7 +303,7 @@ public:
LOG_SCOPE;
// create elements array
assert(decl->tinfo->ty == Ttuple);
assert(decl->tinfo->ty == TY::Ttuple);
TypeTuple *tu = static_cast<TypeTuple *>(decl->tinfo);
size_t dim = tu->arguments->length;
@ -392,7 +392,7 @@ public:
decl->toChars());
LOG_SCOPE;
assert(decl->tinfo->ty == Tvector);
assert(decl->tinfo->ty == TY::Tvector);
TypeVector *tv = static_cast<TypeVector *>(decl->tinfo);
RTTIBuilder b(getVectorTypeInfoType());

2
ir/iraggr.cpp
View file

@ -182,7 +182,7 @@ static llvm::Constant *FillSArrayDims(Type *arrTypeD, llvm::Constant *init) {
return init;
}
if (arrTypeD->ty == Tsarray) {
if (arrTypeD->ty == TY::Tsarray) {
init = FillSArrayDims(arrTypeD->nextOf(), init);
size_t dim = static_cast<TypeSArray *>(arrTypeD)->dim->toUInteger();
llvm::ArrayType *arrty = llvm::ArrayType::get(init->getType(), dim);

2
ir/irclass.cpp
View file

@ -252,7 +252,7 @@ LLConstant *IrClass::getVtblInit() {
}
if (fd->leastAsSpecialized(fd2) || fd2->leastAsSpecialized(fd)) {
TypeFunction *tf = static_cast<TypeFunction *>(fd->type);
if (tf->ty == Tfunction) {
if (tf->ty == TY::Tfunction) {
cd->error("use of `%s%s` is hidden by `%s`; use `alias %s = "
"%s.%s;` to introduce base class overload set",
fd->toPrettyChars(),

2
ir/irfunction.cpp
View file

@ -22,7 +22,7 @@ IrFunction::IrFunction(FuncDeclaration *fd)
decl = fd;
Type *t = fd->type->toBasetype();
assert(t->ty == Tfunction);
assert(t->ty == TY::Tfunction);
type = static_cast<TypeFunction *>(t);
irFty.type = type;

66
ir/irtype.cpp
View file

@ -51,55 +51,55 @@ llvm::Type *IrTypeBasic::basic2llvm(Type *t) {
llvm::LLVMContext &ctx = getGlobalContext();
switch (t->ty) {
case Tvoid:
case Tnoreturn:
case TY::Tvoid:
case TY::Tnoreturn:
return llvm::Type::getVoidTy(ctx);
case Tint8:
case Tuns8:
case Tchar:
case TY::Tint8:
case TY::Tuns8:
case TY::Tchar:
return llvm::Type::getInt8Ty(ctx);
case Tint16:
case Tuns16:
case Twchar:
case TY::Tint16:
case TY::Tuns16:
case TY::Twchar:
return llvm::Type::getInt16Ty(ctx);
case Tint32:
case Tuns32:
case Tdchar:
case TY::Tint32:
case TY::Tuns32:
case TY::Tdchar:
return llvm::Type::getInt32Ty(ctx);
case Tint64:
case Tuns64:
case TY::Tint64:
case TY::Tuns64:
return llvm::Type::getInt64Ty(ctx);
case Tint128:
case Tuns128:
case TY::Tint128:
case TY::Tuns128:
return llvm::IntegerType::get(ctx, 128);
case Tfloat32:
case Timaginary32:
case TY::Tfloat32:
case TY::Timaginary32:
return llvm::Type::getFloatTy(ctx);
case Tfloat64:
case Timaginary64:
case TY::Tfloat64:
case TY::Timaginary64:
return llvm::Type::getDoubleTy(ctx);
case Tfloat80:
case Timaginary80:
case TY::Tfloat80:
case TY::Timaginary80:
return target.realType;
case Tcomplex32:
case TY::Tcomplex32:
return getComplexType(ctx, llvm::Type::getFloatTy(ctx));
case Tcomplex64:
case TY::Tcomplex64:
return getComplexType(ctx, llvm::Type::getDoubleTy(ctx));
case Tcomplex80:
case TY::Tcomplex80:
return getComplexType(ctx, target.realType);
case Tbool:
case TY::Tbool:
return llvm::Type::getInt1Ty(ctx);
default:
llvm_unreachable("Unknown basic type.");
@ -111,13 +111,14 @@ llvm::Type *IrTypeBasic::basic2llvm(Type *t) {
IrTypePointer::IrTypePointer(Type *dt, LLType *lt) : IrType(dt, lt) {}
IrTypePointer *IrTypePointer::get(Type *dt) {
assert((dt->ty == Tpointer || dt->ty == Tnull) && "not pointer/null type");
assert((dt->ty == TY::Tpointer || dt->ty == TY::Tnull) &&
"not pointer/null type");
auto &ctype = getIrType(dt);
assert(!ctype);
LLType *elemType;
if (dt->ty == Tnull) {
if (dt->ty == TY::Tnull) {
elemType = llvm::Type::getInt8Ty(getGlobalContext());
} else {
elemType = DtoMemType(dt->nextOf());
@ -139,7 +140,7 @@ IrTypePointer *IrTypePointer::get(Type *dt) {
IrTypeSArray::IrTypeSArray(Type *dt, LLType *lt) : IrType(dt, lt) {}
IrTypeSArray *IrTypeSArray::get(Type *dt) {
assert(dt->ty == Tsarray && "not static array type");
assert(dt->ty == TY::Tsarray && "not static array type");
auto &ctype = getIrType(dt);
assert(!ctype);
@ -162,7 +163,7 @@ IrTypeSArray *IrTypeSArray::get(Type *dt) {
IrTypeArray::IrTypeArray(Type *dt, LLType *lt) : IrType(dt, lt) {}
IrTypeArray *IrTypeArray::get(Type *dt) {
assert(dt->ty == Tarray && "not dynamic array type");
assert(dt->ty == TY::Tarray && "not dynamic array type");
auto &ctype = getIrType(dt);
assert(!ctype);
@ -214,9 +215,10 @@ IrTypeVector *IrTypeVector::get(Type *dt) {
IrType *&getIrType(Type *t, bool create) {
// See remark in DtoType().
assert((t->ty != Tstruct || t == static_cast<TypeStruct *>(t)->sym->type) &&
"use sd->type for structs");
assert((t->ty != Tclass || t == static_cast<TypeClass *>(t)->sym->type) &&
assert(
(t->ty != TY::Tstruct || t == static_cast<TypeStruct *>(t)->sym->type) &&
"use sd->type for structs");
assert((t->ty != TY::Tclass || t == static_cast<TypeClass *>(t)->sym->type) &&
"use cd->type for classes");
t = stripModifiers(t);

2
ir/irtypefunction.cpp
View file

@ -43,7 +43,7 @@ IrTypeDelegate::IrTypeDelegate(Type *dt, llvm::Type *lt, IrFuncTy irFty_)
: IrType(dt, lt), irFty(std::move(irFty_)) {}
IrTypeDelegate *IrTypeDelegate::get(Type *t) {
assert(t->ty == Tdelegate);
assert(t->ty == TY::Tdelegate);
TypeFunction *tf = t->nextOf()->isTypeFunction();
assert(tf);