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)