}
static IRBuilder<> Builder(getGlobalContext());
struct DebugInfo {
- DICompileUnit TheCU;
- DIType DblTy;
+ DICompileUnit *TheCU;
+ DIType *DblTy;
std::vector<DIScope *> LexicalBlocks;
- std::map<const PrototypeAST *, DIScope> FnScopeMap;
+ std::map<const PrototypeAST *, DIScope *> FnScopeMap;
void emitLocation(ExprAST *AST);
- DIType getDoubleTy();
+ DIType *getDoubleTy();
} KSDbgInfo;
static std::string IdentifierStr; // Filled in if tok_identifier
static DIBuilder *DBuilder;
-DIType DebugInfo::getDoubleTy() {
- if (DblTy.isValid())
+DIType *DebugInfo::getDoubleTy() {
+ if (DblTy)
return DblTy;
DblTy = DBuilder->createBasicType("double", 64, 64, dwarf::DW_ATE_float);
return Builder.SetCurrentDebugLocation(DebugLoc());
DIScope *Scope;
if (LexicalBlocks.empty())
- Scope = &TheCU;
+ Scope = TheCU;
else
Scope = LexicalBlocks.back();
Builder.SetCurrentDebugLocation(
- DebugLoc::get(AST->getLine(), AST->getCol(), DIScope(*Scope)));
+ DebugLoc::get(AST->getLine(), AST->getCol(), Scope));
}
-static DICompositeType CreateFunctionType(unsigned NumArgs, DIFile Unit) {
+static DISubroutineType *CreateFunctionType(unsigned NumArgs, DIFile *Unit) {
SmallVector<Metadata *, 8> EltTys;
- DIType DblTy = KSDbgInfo.getDoubleTy();
+ DIType *DblTy = KSDbgInfo.getDoubleTy();
// Add the result type.
EltTys.push_back(DblTy);
for (unsigned i = 0, e = NumArgs; i != e; ++i)
EltTys.push_back(DblTy);
- DITypeArray EltTypeArray = DBuilder->getOrCreateTypeArray(EltTys);
- return DBuilder->createSubroutineType(Unit, EltTypeArray);
+ return DBuilder->createSubroutineType(Unit,
+ DBuilder->getOrCreateTypeArray(EltTys));
}
//===----------------------------------------------------------------------===//
// Special case '=' because we don't want to emit the LHS as an expression.
if (Op == '=') {
// Assignment requires the LHS to be an identifier.
- VariableExprAST *LHSE = dynamic_cast<VariableExprAST *>(LHS);
+ // This assume we're building without RTTI because LLVM builds that way by
+ // default. If you build LLVM with RTTI this can be changed to a
+ // dynamic_cast for automatic error checking.
+ VariableExprAST *LHSE = static_cast<VariableExprAST *>(LHS);
if (!LHSE)
return ErrorV("destination of '=' must be a variable");
// Codegen the RHS.
AI->setName(Args[Idx]);
// Create a subprogram DIE for this function.
- DIFile Unit = DBuilder->createFile(KSDbgInfo.TheCU.getFilename(),
- KSDbgInfo.TheCU.getDirectory());
- DIDescriptor FContext(Unit);
+ DIFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
+ KSDbgInfo.TheCU->getDirectory());
+ DIScope *FContext = Unit;
unsigned LineNo = Line;
unsigned ScopeLine = Line;
- DISubprogram SP = DBuilder->createFunction(
+ DISubprogram *SP = DBuilder->createFunction(
FContext, Name, StringRef(), Unit, LineNo,
CreateFunctionType(Args.size(), Unit), false /* internal linkage */,
- true /* definition */, ScopeLine, DIDescriptor::FlagPrototyped, false, F);
+ true /* definition */, ScopeLine, DINode::FlagPrototyped, false, F);
KSDbgInfo.FnScopeMap[this] = SP;
return F;
// Create a debug descriptor for the variable.
DIScope *Scope = KSDbgInfo.LexicalBlocks.back();
- DIFile Unit = DBuilder->createFile(KSDbgInfo.TheCU.getFilename(),
- KSDbgInfo.TheCU.getDirectory());
- DIVariable D = DBuilder->createLocalVariable(dwarf::DW_TAG_arg_variable,
- *Scope, Args[Idx], Unit, Line,
- KSDbgInfo.getDoubleTy(), Idx);
+ DIFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
+ KSDbgInfo.TheCU->getDirectory());
+ DILocalVariable *D = DBuilder->createLocalVariable(
+ dwarf::DW_TAG_arg_variable, Scope, Args[Idx], Unit, Line,
+ KSDbgInfo.getDoubleTy(), true, 0, Idx + 1);
- Instruction *Call = DBuilder->insertDeclare(
- Alloca, D, DBuilder->createExpression(), Builder.GetInsertBlock());
- Call->setDebugLoc(DebugLoc::get(Line, 0, *Scope));
+ DBuilder->insertDeclare(Alloca, D, DBuilder->createExpression(),
+ DebugLoc::get(Line, 0, Scope),
+ Builder.GetInsertBlock());
// Store the initial value into the alloca.
Builder.CreateStore(AI, Alloca);
return 0;
// Push the current scope.
- KSDbgInfo.LexicalBlocks.push_back(&KSDbgInfo.FnScopeMap[Proto]);
+ KSDbgInfo.LexicalBlocks.push_back(KSDbgInfo.FnScopeMap[Proto]);
// Unset the location for the prologue emission (leading instructions with no
// location in a function are considered part of the prologue and the debugger
// Set up the optimizer pipeline. Start with registering info about how the
// target lays out data structures.
- TheModule->setDataLayout(*TheExecutionEngine->getDataLayout());
+ TheModule->setDataLayout(TheExecutionEngine->getDataLayout());
#if 0
// Provide basic AliasAnalysis support for GVN.
OurFPM.add(createBasicAliasAnalysisPass());