static QualifiedType
returnInfoArrayIndexValue(CallExpr* call) {
Type* type = call->get(1)->typeInfo();
if (type->symbol->hasFlag(FLAG_WIDE_CLASS))
type = type->getField("addr")->type;
if (!type->substitutions.n)
INT_FATAL(call, "bad primitive");
// Is this conditional necessary? Can just assume condition is true?
if (type->symbol->hasFlag(FLAG_DATA_CLASS)) {
return QualifiedType(toTypeSymbol(getDataClassType(type->symbol))->type, QUAL_VAL);
}
else {
return QualifiedType(toTypeSymbol(type->substitutions.v[0].value)->type, QUAL_VAL);
}
}
static Type*
returnInfoArrayIndexValue(CallExpr* call) {
SymExpr* sym = toSymExpr(call->get(1));
INT_ASSERT(sym);
Type* type = sym->var->type;
if (type->symbol->hasFlag(FLAG_WIDE_CLASS))
type = type->getField("addr")->type;
if (!type->substitutions.n)
INT_FATAL(call, "bad primitive");
// Is this conditional necessary? Can just assume condition is true?
if (type->symbol->hasFlag(FLAG_DATA_CLASS)) {
return toTypeSymbol(getDataClassType(type->symbol))->type;
}
else {
return toTypeSymbol(type->substitutions.v[0].value)->type;
}
}
LLVM_DITYPE debug_data::construct_type(Type *type)
{
llvm::MDNode *N = myGetType(type);
if(N) return toDITYPE(N);
GenInfo* info = gGenInfo;
LLVM_TARGET_DATA *layout = info->targetData;
llvm::Type* ty = type->symbol->llvmType;
const char* name = type->symbol->name;
ModuleSymbol* defModule = type->symbol->getModule();
const char* defFile = type->symbol->fname();
if (strstr(defFile, "/modules/")!=NULL || strcmp(defFile, "<internal>")==0) {
#if HAVE_LLVM_VER >= 37
return NULL;
#else
return llvm::DIType();
#endif
}
int defLine = type->symbol->linenum();
if(!ty) {
#if HAVE_LLVM_VER >= 37
return NULL;
#else
return llvm::DIType();
#endif
}
if(ty->isIntegerTy()) {
N = this->dibuilder.createBasicType(
name,
layout->getTypeSizeInBits(ty),
8*layout->getABITypeAlignment(ty),
(is_signed(type))?
(llvm::dwarf::DW_ATE_signed):
(llvm::dwarf::DW_ATE_unsigned));
myTypeDescriptors[type] = N;
return toDITYPE(N);
}
else if(ty->isFloatingPointTy()) {
N = this->dibuilder.createBasicType(
name,
layout->getTypeSizeInBits(ty),
8*layout->getABITypeAlignment(ty),
llvm::dwarf::DW_ATE_float);
myTypeDescriptors[type] = N;
return toDITYPE(N);
}
else if(ty->isPointerTy()) {
if(type != type->getValType()) {//Add this condition to avoid segFault
N = this->dibuilder.createPointerType(
get_type(type->getValType()),//it should return the pointee's DIType
layout->getPointerSizeInBits(ty->getPointerAddressSpace()),
0, /* alignment */
name);
myTypeDescriptors[type] = N;
return toDITYPE(N);
}
else {
if(type->astTag == E_PrimitiveType) {
llvm::Type *PointeeTy = ty->getPointerElementType();
// handle string, c_string, c_string_copy, nil, opaque, c_void_ptr
if(PointeeTy->isIntegerTy()) {
LLVM_DITYPE pteIntDIType; //create the DI-pointeeType
pteIntDIType = this->dibuilder.createBasicType(
myGetTypeName(PointeeTy),
layout->getTypeSizeInBits(PointeeTy),
8*layout->getABITypeAlignment(PointeeTy),
llvm::dwarf::DW_ATE_unsigned);
N = this->dibuilder.createPointerType(
pteIntDIType,
layout->getPointerSizeInBits(ty->getPointerAddressSpace()),
0,
name);
myTypeDescriptors[type] = N;
return toDITYPE(N);
}
// handle qio_channel_ptr_t, _task_list, qio_file_ptr_t, syserr, _file
else if(PointeeTy->isStructTy()) {
LLVM_DITYPE pteStrDIType; //create the DI-pointeeType
pteStrDIType = this->dibuilder.createStructType(
get_module_scope(defModule),
PointeeTy->getStructName(),
get_file(defFile),
0,
(PointeeTy->isSized()?
layout->getTypeSizeInBits(PointeeTy):
8),
(PointeeTy->isSized()?
8*layout->getABITypeAlignment(PointeeTy):
8),
0,
toDITYPE(NULL),
#if HAVE_LLVM_VER >= 37
NULL
#else
llvm::DIArray(NULL)
#endif
);
N = this->dibuilder.createPointerType(
pteStrDIType,
layout->getPointerSizeInBits(ty->getPointerAddressSpace()),
0,
name);
myTypeDescriptors[type] = N;
return toDITYPE(N);
}
}
else if(type->astTag == E_AggregateType) {
// dealing with classes
AggregateType *this_class = (AggregateType *)type;
llvm::SmallVector<LLVM_METADATA_OPERAND_TYPE *, 8> EltTys;
LLVM_DITYPE derivedFrom = nullptr;
if( type->dispatchParents.length() > 0 )
derivedFrom = get_type(type->dispatchParents.first());
// solve the data class: _ddata
if(this_class->symbol->hasFlag(FLAG_DATA_CLASS)) {
Type* vt = getDataClassType(this_class->symbol)->typeInfo();
if(vt) {
N = this->dibuilder.createPointerType(
get_type(vt),
layout->getPointerSizeInBits(ty->getPointerAddressSpace()),
0,
name);
myTypeDescriptors[type] = N;
return toDITYPE(N);
}
} //Not sure whether we should directly return getType(vt)
const llvm::StructLayout* slayout = NULL;
const char *struct_name = this_class->classStructName(true);
llvm::Type* st = getTypeLLVM(struct_name);
if(st){
llvm::StructType* struct_type = llvm::cast<llvm::StructType>(st);
if(!struct_type->isOpaque()){
N = this->dibuilder.createForwardDecl(
llvm::dwarf::DW_TAG_structure_type,
name,
get_module_scope(defModule),
get_file(defFile),
defLine,
0, // RuntimeLang
layout->getTypeSizeInBits(ty),
8*layout->getABITypeAlignment(ty));
//N is added to the map (early) so that element search below can find it,
//so as to avoid infinite recursion for structs that contain pointers to
//their own type.
myTypeDescriptors[type] = N;
slayout = layout->getStructLayout(struct_type);
for_fields(field, this_class) {
// field is a Symbol
const char* fieldDefFile = field->defPoint->fname();
int fieldDefLine = field->defPoint->linenum();
TypeSymbol* fts = field->type->symbol;
llvm::Type* fty = fts->llvmType;
LLVM_DITYPE mty;
LLVM_DITYPE fditype = get_type(field->type);
if(fditype == NULL)
// if field->type is an internal type, get_type returns null
// which is not a good type for a MemberType). At the moment it
// uses a nullptr type as a stub, but we should change it
fditype = this->dibuilder.createNullPtrType();
//use the dummy type for 'BaseArr'
mty = this->dibuilder.createMemberType(
get_module_scope(defModule),
field->name,
get_file(fieldDefFile),
fieldDefLine,
layout->getTypeSizeInBits(fty),
8*layout->getABITypeAlignment(fty),
slayout->getElementOffsetInBits(this_class->getMemberGEP(field->cname)),
0,
fditype);
EltTys.push_back(mty);
}
// Now create the DItype for the struct
N = this->dibuilder.createStructType(
get_module_scope(defModule),
name,
get_file(defFile),
defLine,
layout->getTypeSizeInBits(ty),
8*layout->getABITypeAlignment(ty),
0, // RuntimeLang
derivedFrom,
this->dibuilder.getOrCreateArray(EltTys));
return toDITYPE(N);
}//end of if(!Opaque)
}// end of if(st)
} // end of astTag == E_AggregateTy
} // end of else (type==type->getType)
