/// CreateType - get structure or union type.
llvm::DIType CGDebugInfo::CreateType(const RecordType *Ty,
llvm::DICompileUnit Unit) {
RecordDecl *Decl = Ty->getDecl();
unsigned Tag;
if (Decl->isStruct())
Tag = llvm::dwarf::DW_TAG_structure_type;
else if (Decl->isUnion())
Tag = llvm::dwarf::DW_TAG_union_type;
else {
assert(Decl->isClass() && "Unknown RecordType!");
Tag = llvm::dwarf::DW_TAG_class_type;
}
SourceManager &SM = M->getContext().getSourceManager();
// Get overall information about the record type for the debug info.
std::string Name = Decl->getNameAsString();
llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(Decl->getLocation());
unsigned Line = SM.getInstantiationLineNumber(Decl->getLocation());
// Records and classes and unions can all be recursive. To handle them, we
// first generate a debug descriptor for the struct as a forward declaration.
// Then (if it is a definition) we go through and get debug info for all of
// its members. Finally, we create a descriptor for the complete type (which
// may refer to the forward decl if the struct is recursive) and replace all
// uses of the forward declaration with the final definition.
llvm::DIType FwdDecl =
DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, 0, 0, 0, 0,
llvm::DIType(), llvm::DIArray());
// If this is just a forward declaration, return it.
if (!Decl->getDefinition(M->getContext()))
return FwdDecl;
// Otherwise, insert it into the TypeCache so that recursive uses will find
// it.
TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl;
// Convert all the elements.
llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
const ASTRecordLayout &RL = M->getContext().getASTRecordLayout(Decl);
unsigned FieldNo = 0;
for (RecordDecl::field_iterator I = Decl->field_begin(M->getContext()),
E = Decl->field_end(M->getContext());
I != E; ++I, ++FieldNo) {
FieldDecl *Field = *I;
llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
std::string FieldName = Field->getNameAsString();
// Get the location for the field.
SourceLocation FieldDefLoc = Field->getLocation();
llvm::DICompileUnit FieldDefUnit = getOrCreateCompileUnit(FieldDefLoc);
unsigned FieldLine = SM.getInstantiationLineNumber(FieldDefLoc);
QualType FType = Field->getType();
uint64_t FieldSize = 0;
unsigned FieldAlign = 0;
if (!FType->isIncompleteArrayType()) {
// Bit size, align and offset of the type.
FieldSize = M->getContext().getTypeSize(FType);
Expr *BitWidth = Field->getBitWidth();
if (BitWidth)
FieldSize =
BitWidth->getIntegerConstantExprValue(M->getContext()).getZExtValue();
FieldAlign = M->getContext().getTypeAlign(FType);
}
uint64_t FieldOffset = RL.getFieldOffset(FieldNo);
// Create a DW_TAG_member node to remember the offset of this field in the
// struct. FIXME: This is an absolutely insane way to capture this
// information. When we gut debug info, this should be fixed.
FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
FieldName, FieldDefUnit,
FieldLine, FieldSize, FieldAlign,
FieldOffset, 0, FieldTy);
EltTys.push_back(FieldTy);
}
llvm::DIArray Elements =
DebugFactory.GetOrCreateArray(&EltTys[0], EltTys.size());
// Bit size, align and offset of the type.
uint64_t Size = M->getContext().getTypeSize(Ty);
uint64_t Align = M->getContext().getTypeAlign(Ty);
llvm::DIType RealDecl =
DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, Size,
Align, 0, 0, llvm::DIType(), Elements);
// Now that we have a real decl for the struct, replace anything using the
// old decl with the new one. This will recursively update the debug info.
FwdDecl.getGV()->replaceAllUsesWith(RealDecl.getGV());
FwdDecl.getGV()->eraseFromParent();
return RealDecl;
}
void DeclContextPrinter::PrintDeclContext(const DeclContext* DC,
unsigned Indentation) {
// Print DeclContext name.
switch (DC->getDeclKind()) {
case Decl::TranslationUnit:
Out << "[translation unit] " << DC;
break;
case Decl::Namespace: {
Out << "[namespace] ";
const NamespaceDecl* ND = cast<NamespaceDecl>(DC);
Out << ND->getNameAsString();
break;
}
case Decl::Enum: {
const EnumDecl* ED = cast<EnumDecl>(DC);
if (ED->isDefinition())
Out << "[enum] ";
else
Out << "<enum> ";
Out << ED->getNameAsString();
break;
}
case Decl::Record: {
const RecordDecl* RD = cast<RecordDecl>(DC);
if (RD->isDefinition())
Out << "[struct] ";
else
Out << "<struct> ";
Out << RD->getNameAsString();
break;
}
case Decl::CXXRecord: {
const CXXRecordDecl* RD = cast<CXXRecordDecl>(DC);
if (RD->isDefinition())
Out << "[class] ";
else
Out << "<class> ";
Out << RD->getNameAsString() << " " << DC;
break;
}
case Decl::ObjCMethod:
Out << "[objc method]";
break;
case Decl::ObjCInterface:
Out << "[objc interface]";
break;
case Decl::ObjCCategory:
Out << "[objc category]";
break;
case Decl::ObjCProtocol:
Out << "[objc protocol]";
break;
case Decl::ObjCImplementation:
Out << "[objc implementation]";
break;
case Decl::ObjCCategoryImpl:
Out << "[objc categoryimpl]";
break;
case Decl::LinkageSpec:
Out << "[linkage spec]";
break;
case Decl::Block:
Out << "[block]";
break;
case Decl::Function: {
const FunctionDecl* FD = cast<FunctionDecl>(DC);
if (FD->isThisDeclarationADefinition())
Out << "[function] ";
else
Out << "<function> ";
Out << FD->getNameAsString();
// Print the parameters.
Out << "(";
bool PrintComma = false;
for (FunctionDecl::param_const_iterator I = FD->param_begin(),
E = FD->param_end(); I != E; ++I) {
if (PrintComma)
Out << ", ";
else
PrintComma = true;
Out << (*I)->getNameAsString();
}
Out << ")";
break;
}
case Decl::CXXMethod: {
const CXXMethodDecl* D = cast<CXXMethodDecl>(DC);
if (D->isOutOfLineDefinition())
Out << "[c++ method] ";
else if (D->isImplicit())
Out << "(c++ method) ";
else
Out << "<c++ method> ";
Out << D->getNameAsString();
// Print the parameters.
Out << "(";
bool PrintComma = false;
for (FunctionDecl::param_const_iterator I = D->param_begin(),
E = D->param_end(); I != E; ++I) {
if (PrintComma)
Out << ", ";
else
PrintComma = true;
Out << (*I)->getNameAsString();
}
Out << ")";
// Check the semantic DeclContext.
const DeclContext* SemaDC = D->getDeclContext();
const DeclContext* LexicalDC = D->getLexicalDeclContext();
if (SemaDC != LexicalDC)
Out << " [[" << SemaDC << "]]";
break;
}
case Decl::CXXConstructor: {
const CXXConstructorDecl* D = cast<CXXConstructorDecl>(DC);
if (D->isOutOfLineDefinition())
Out << "[c++ ctor] ";
else if (D->isImplicit())
Out << "(c++ ctor) ";
else
Out << "<c++ ctor> ";
Out << D->getNameAsString();
// Print the parameters.
Out << "(";
bool PrintComma = false;
for (FunctionDecl::param_const_iterator I = D->param_begin(),
E = D->param_end(); I != E; ++I) {
if (PrintComma)
Out << ", ";
else
PrintComma = true;
Out << (*I)->getNameAsString();
}
Out << ")";
// Check the semantic DC.
const DeclContext* SemaDC = D->getDeclContext();
const DeclContext* LexicalDC = D->getLexicalDeclContext();
if (SemaDC != LexicalDC)
Out << " [[" << SemaDC << "]]";
break;
}
case Decl::CXXDestructor: {
const CXXDestructorDecl* D = cast<CXXDestructorDecl>(DC);
if (D->isOutOfLineDefinition())
Out << "[c++ dtor] ";
else if (D->isImplicit())
Out << "(c++ dtor) ";
else
Out << "<c++ dtor> ";
Out << D->getNameAsString();
// Check the semantic DC.
const DeclContext* SemaDC = D->getDeclContext();
const DeclContext* LexicalDC = D->getLexicalDeclContext();
if (SemaDC != LexicalDC)
Out << " [[" << SemaDC << "]]";
break;
}
case Decl::CXXConversion: {
const CXXConversionDecl* D = cast<CXXConversionDecl>(DC);
if (D->isOutOfLineDefinition())
Out << "[c++ conversion] ";
else if (D->isImplicit())
Out << "(c++ conversion) ";
else
Out << "<c++ conversion> ";
Out << D->getNameAsString();
// Check the semantic DC.
const DeclContext* SemaDC = D->getDeclContext();
const DeclContext* LexicalDC = D->getLexicalDeclContext();
if (SemaDC != LexicalDC)
Out << " [[" << SemaDC << "]]";
break;
}
default:
assert(0 && "a decl that inherits DeclContext isn't handled");
}
Out << "\n";
// Print decls in the DeclContext.
// FIXME: Should not use a NULL DeclContext!
ASTContext *Context = 0;
for (DeclContext::decl_iterator I = DC->decls_begin(*Context),
E = DC->decls_end(*Context);
I != E; ++I) {
for (unsigned i = 0; i < Indentation; ++i)
Out << " ";
Decl::Kind DK = I->getKind();
switch (DK) {
case Decl::Namespace:
case Decl::Enum:
case Decl::Record:
case Decl::CXXRecord:
case Decl::ObjCMethod:
case Decl::ObjCInterface:
case Decl::ObjCCategory:
case Decl::ObjCProtocol:
case Decl::ObjCImplementation:
case Decl::ObjCCategoryImpl:
case Decl::LinkageSpec:
case Decl::Block:
case Decl::Function:
case Decl::CXXMethod:
case Decl::CXXConstructor:
case Decl::CXXDestructor:
case Decl::CXXConversion:
{
DeclContext* DC = cast<DeclContext>(*I);
PrintDeclContext(DC, Indentation+2);
break;
}
case Decl::Field: {
FieldDecl* FD = cast<FieldDecl>(*I);
Out << "<field> " << FD->getNameAsString() << "\n";
break;
}
case Decl::Typedef: {
TypedefDecl* TD = cast<TypedefDecl>(*I);
Out << "<typedef> " << TD->getNameAsString() << "\n";
break;
}
case Decl::EnumConstant: {
EnumConstantDecl* ECD = cast<EnumConstantDecl>(*I);
Out << "<enum constant> " << ECD->getNameAsString() << "\n";
break;
}
case Decl::Var: {
VarDecl* VD = cast<VarDecl>(*I);
Out << "<var> " << VD->getNameAsString() << "\n";
break;
}
case Decl::ImplicitParam: {
ImplicitParamDecl* IPD = cast<ImplicitParamDecl>(*I);
Out << "<implicit parameter> " << IPD->getNameAsString() << "\n";
break;
}
case Decl::ParmVar: {
ParmVarDecl* PVD = cast<ParmVarDecl>(*I);
Out << "<parameter> " << PVD->getNameAsString() << "\n";
break;
}
case Decl::OriginalParmVar: {
OriginalParmVarDecl* OPVD = cast<OriginalParmVarDecl>(*I);
Out << "<original parameter> " << OPVD->getNameAsString() << "\n";
break;
}
case Decl::ObjCProperty: {
ObjCPropertyDecl* OPD = cast<ObjCPropertyDecl>(*I);
Out << "<objc property> " << OPD->getNameAsString() << "\n";
break;
}
default:
fprintf(stderr, "DeclKind: %d \"%s\"\n", DK, I->getDeclKindName());
assert(0 && "decl unhandled");
}
}
}
bool TransferFunctions::checkImageAccess(Expr *E, MemoryAccess curMemAcc) {
// discard implicit casts and paren expressions
E = E->IgnoreParenImpCasts();
// match Image(), Accessor(), Mask(), and Domain() calls
if (isa<CXXOperatorCallExpr>(E)) {
CXXOperatorCallExpr *COCE = dyn_cast<CXXOperatorCallExpr>(E);
if (isa<MemberExpr>(COCE->getArg(0))) {
MemberExpr *ME = dyn_cast<MemberExpr>(COCE->getArg(0));
if (isa<FieldDecl>(ME->getMemberDecl())) {
FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
MemoryAccess memAcc = KS.imagesToAccess[FD];
MemoryAccessDetail memAccDetail = KS.imagesToAccessDetail[FD];
memAcc = (MemoryAccess) (memAcc|curMemAcc);
KS.imagesToAccess[FD] = memAcc;
// access to Image
if (KS.compilerClasses.isTypeOfTemplateClass(FD->getType(),
KS.compilerClasses.Image)) {
KS.Diags.Report(E->getLocStart(), KS.DiagIDImageAccess) <<
FD->getNameAsString();
exit(EXIT_FAILURE);
}
// access to Accessor
if (KS.compilerClasses.isTypeOfTemplateClass(FD->getType(),
KS.compilerClasses.Accessor)) {
if (curMemAcc & READ_ONLY) KS.num_img_loads++;
if (curMemAcc & WRITE_ONLY) KS.num_img_stores++;
switch (COCE->getNumArgs()) {
default:
break;
case 1:
memAccDetail = (MemoryAccessDetail) (memAccDetail|NO_STRIDE);
if (KS.kernelType < PointOperator) KS.kernelType = PointOperator;
break;
case 2:
// TODO: check for Mask or Domain as parameter and check if we
// need only STRIDE_X or STRIDE_Y
memAccDetail = (MemoryAccessDetail) (memAccDetail|STRIDE_XY);
if (KS.kernelType < LocalOperator) KS.kernelType = LocalOperator;
break;
case 3:
memAccDetail = (MemoryAccessDetail)
(memAccDetail|checkStride(COCE->getArg(1), COCE->getArg(2)));
if (memAccDetail > NO_STRIDE && KS.kernelType < LocalOperator) {
KS.kernelType = LocalOperator;
}
break;
}
KS.imagesToAccessDetail[FD] = memAccDetail;
return true;
}
// access to Mask
if (KS.compilerClasses.isTypeOfTemplateClass(FD->getType(),
KS.compilerClasses.Mask)) {
if (curMemAcc & READ_ONLY) KS.num_mask_loads++;
if (curMemAcc & WRITE_ONLY) KS.num_mask_stores++;
if (KS.inLambdaFunction) {
// TODO: check for Mask as parameter and check if we need only
// STRIDE_X or STRIDE_Y
memAccDetail = (MemoryAccessDetail) (memAccDetail|STRIDE_XY);
if (KS.kernelType < LocalOperator) KS.kernelType = LocalOperator;
} else {
assert(COCE->getNumArgs()==3 &&
"Mask access requires x and y parameters!");
memAccDetail = (MemoryAccessDetail)
(memAccDetail|checkStride(COCE->getArg(1), COCE->getArg(2)));
if (memAccDetail > NO_STRIDE && KS.kernelType < LocalOperator) {
KS.kernelType = LocalOperator;
}
}
KS.imagesToAccessDetail[FD] = memAccDetail;
return false;
}
// access to Domain
if (KS.compilerClasses.isTypeOfClass(FD->getType(),
KS.compilerClasses.Domain)) {
if (curMemAcc & READ_ONLY) KS.num_mask_loads++;
if (curMemAcc & WRITE_ONLY) KS.num_mask_stores++;
if (KS.inLambdaFunction) {
// TODO: check for Domain as parameter and check if we need only
// STRIDE_X or STRIDE_Y
memAccDetail = (MemoryAccessDetail) (memAccDetail|STRIDE_XY);
if (KS.kernelType < LocalOperator) KS.kernelType = LocalOperator;
} else {
assert(COCE->getNumArgs()==3 &&
"Domain access requires x and y parameters!");
memAccDetail = (MemoryAccessDetail)
(memAccDetail|checkStride(COCE->getArg(1), COCE->getArg(2)));
if (memAccDetail > NO_STRIDE && KS.kernelType < LocalOperator) {
KS.kernelType = LocalOperator;
}
}
KS.imagesToAccessDetail[FD] = memAccDetail;
return false;
}
}
}
}
// match Image->getPixel(), output(), and outputAtPixel() calls
if (isa<CXXMemberCallExpr>(E)) {
CXXMemberCallExpr *CMCE = dyn_cast<CXXMemberCallExpr>(E);
if (isa<MemberExpr>(CMCE->getCallee())) {
MemberExpr *ME = dyn_cast<MemberExpr>(CMCE->getCallee());
if (isa<MemberExpr>(ME->getBase())) {
MemberExpr *MEAcc = dyn_cast<MemberExpr>(ME->getBase());
if (isa<FieldDecl>(MEAcc->getMemberDecl())) {
FieldDecl *FD = dyn_cast<FieldDecl>(MEAcc->getMemberDecl());
// Image
if (KS.compilerClasses.isTypeOfTemplateClass(FD->getType(),
KS.compilerClasses.Image)) {
KS.Diags.Report(E->getLocStart(), KS.DiagIDImageAccess) <<
FD->getNameAsString();
exit(EXIT_FAILURE);
}
// Accessor
if (KS.compilerClasses.isTypeOfTemplateClass(FD->getType(),
KS.compilerClasses.Accessor)) {
// Accessor->getPixel()
if (ME->getMemberNameInfo().getAsString()=="getPixel") {
MemoryAccess memAcc = KS.imagesToAccess[FD];
MemoryAccessDetail memAccDetail = KS.imagesToAccessDetail[FD];
memAcc = (MemoryAccess) (memAcc|curMemAcc);
KS.imagesToAccess[FD] = memAcc;
memAccDetail = (MemoryAccessDetail) (memAccDetail|USER_XY);
KS.imagesToAccessDetail[FD] = memAccDetail;
KS.kernelType = UserOperator;
if (curMemAcc & READ_ONLY) KS.num_img_loads++;
if (curMemAcc & WRITE_ONLY) KS.num_img_stores++;
return true;
}
}
}
}
// output()
if (ME->getMemberNameInfo().getAsString()=="output") {
if (curMemAcc & READ_ONLY) KS.num_img_loads++;
if (curMemAcc & WRITE_ONLY) KS.num_img_stores++;
MemoryAccessDetail cur = KS.outputAccessDetail;
KS.outputAccessDetail = (MemoryAccessDetail)(cur|NO_STRIDE);
if (KS.kernelType < PointOperator) KS.kernelType = PointOperator;
return true;
}
// outputAtPixel()
if (ME->getMemberNameInfo().getAsString()=="outputAtPixel") {
if (curMemAcc & READ_ONLY) KS.num_img_loads++;
if (curMemAcc & WRITE_ONLY) KS.num_img_stores++;
MemoryAccessDetail cur = KS.outputAccessDetail;
KS.outputAccessDetail = (MemoryAccessDetail)(cur|USER_XY);
KS.kernelType = UserOperator;
return true;
}
}
}
return false;
}
