Refine types based on debug metadata

include/rellic/AST/ASTBuilder.h

@@ -257,6 +257,16 @@ class ASTBuilder {
   clang::BreakStmt *CreateBreak();
   // Return
   clang::ReturnStmt *CreateReturn(clang::Expr *retval = nullptr);
+  // Typedef declaration
+  clang::TypedefDecl *CreateTypedefDecl(clang::DeclContext *decl_ctx,
+                                        clang::IdentifierInfo *id,
+                                        clang::QualType type);
+
+  clang::TypedefDecl *CreateTypedefDecl(clang::DeclContext *decl_ctx,
+                                        std::string name,
+                                        clang::QualType type) {
+    return CreateTypedefDecl(decl_ctx, CreateIdentifier(name), type);
+  }
 };
 
 }  // namespace rellic

include/rellic/AST/ASTPrinter.h

@@ -101,6 +101,7 @@ class DeclTokenizer : public clang::DeclVisitor<DeclTokenizer> {
   void VisitTranslationUnitDecl(clang::TranslationUnitDecl *decl);
   void VisitFieldDecl(clang::FieldDecl *decl);
   void VisitRecordDecl(clang::RecordDecl *decl);
+  void VisitTypedefDecl(clang::TypedefDecl *decl);
 };
 
 class StmtTokenizer : public clang::StmtVisitor<StmtTokenizer> {

include/rellic/AST/DebugInfoCollector.h

@@ -17,12 +17,14 @@
 namespace rellic {
 
 using IRToNameMap = std::unordered_map<llvm::Value *, std::string>;
-using IRToScopeMap = std::unordered_map<llvm::Value *, llvm::DILocalScope *>;
+using IRToScopeMap = std::unordered_map<llvm::Value *, llvm::DIScope *>;
 using IRToDITypeMap = std::unordered_map<llvm::Value *, llvm::DIType *>;
 using IRTypeToDITypeMap = std::unordered_map<llvm::Type *, llvm::DIType *>;
 using IRFuncToDITypeMap =
     std::unordered_map<llvm::Function *, llvm::DISubroutineType *>;
 using IRArgToDITypeMap = std::unordered_map<llvm::Argument *, llvm::DIType *>;
+using IRFuncTypeToDIRetTypeMap =
+    std::unordered_map<llvm::FunctionType *, llvm::DIType *>;
 
 class DebugInfoCollector : public llvm::InstVisitor<DebugInfoCollector> {
  private:
@@ -32,6 +34,7 @@ class DebugInfoCollector : public llvm::InstVisitor<DebugInfoCollector> {
   IRTypeToDITypeMap types;
   IRFuncToDITypeMap funcs;
   IRArgToDITypeMap args;
+  IRFuncTypeToDIRetTypeMap ret_types;
 
   void WalkType(llvm::Type *type, llvm::DIType *ditype);
 
@@ -42,11 +45,13 @@ class DebugInfoCollector : public llvm::InstVisitor<DebugInfoCollector> {
   IRTypeToDITypeMap &GetIRTypeToDITypeMap() { return types; }
   IRFuncToDITypeMap &GetIRFuncToDITypeMap() { return funcs; }
   IRArgToDITypeMap &GetIRArgToDITypeMap() { return args; }
+  IRFuncTypeToDIRetTypeMap &GetIRFuncTypeToDIRetTypeMap() { return ret_types; }
 
   void visitDbgDeclareInst(llvm::DbgDeclareInst &inst);
   void visitInstruction(llvm::Instruction &inst);
 
   void visitFunction(llvm::Function &func);
+  void visitModule(llvm::Module &module);
 };
 
 }  // namespace rellic

include/rellic/AST/GenerateAST.h

@@ -51,7 +51,7 @@ class GenerateAST : public llvm::ModulePass {
  public:
   static char ID;
 
-  GenerateAST(clang::ASTUnit &unit);
+  GenerateAST(clang::ASTUnit &unit, DebugInfoCollector &dic);
 
   IRToStmtMap &GetIRToStmtMap() { return ast_gen.GetIRToStmtMap(); }
   IRToValDeclMap &GetIRToValDeclMap() { return ast_gen.GetIRToValDeclMap(); }

include/rellic/AST/IRToASTVisitor.h

@@ -22,12 +22,15 @@
 
 #include "rellic/AST/ASTBuilder.h"
 #include "rellic/AST/Compat/ASTContext.h"
+#include "rellic/AST/DebugInfoCollector.h"
 
 namespace rellic {
 
 using IRToTypeDeclMap = std::unordered_map<llvm::Type *, clang::TypeDecl *>;
 using IRToValDeclMap = std::unordered_map<llvm::Value *, clang::ValueDecl *>;
 using IRToStmtMap = std::unordered_map<llvm::Value *, clang::Stmt *>;
+using DIToTypedefMap =
+    std::unordered_map<llvm::DIDerivedType *, clang::TypedefNameDecl *>;
 using ArgToTempMap = std::unordered_map<llvm::Argument *, clang::VarDecl *>;
 
 class IRToASTVisitor : public llvm::InstVisitor<IRToASTVisitor> {
@@ -38,18 +41,21 @@ class IRToASTVisitor : public llvm::InstVisitor<IRToASTVisitor> {
 
   IRToTypeDeclMap type_decls;
   IRToValDeclMap value_decls;
+  DIToTypedefMap typedef_decls;
   IRToStmtMap stmts;
+  DebugInfoCollector &dic;
   ArgToTempMap temp_decls;
 
   clang::Expr *GetOperandExpr(llvm::Value *val);
+  clang::QualType GetQualType(llvm::Type *type, llvm::DIType *ditype);
   clang::QualType GetQualType(llvm::Type *type);
 
   clang::Expr *CreateLiteralExpr(llvm::Constant *constant);
 
   clang::Decl *GetOrCreateIntrinsic(llvm::InlineAsm *val);
 
  public:
-  IRToASTVisitor(clang::ASTUnit &unit);
+  IRToASTVisitor(clang::ASTUnit &unit, DebugInfoCollector &dic);
 
   clang::Stmt *GetOrCreateStmt(llvm::Value *val);
   clang::Decl *GetOrCreateDecl(llvm::Value *val);

include/rellic/BC/Util.h

@@ -24,6 +24,7 @@ namespace rellic {
 // Serialize an LLVM object into a string.
 std::string LLVMThingToString(llvm::Value *thing);
 std::string LLVMThingToString(llvm::Type *thing);
+std::string LLVMThingToString(llvm::DIType *thing);
 
 // Try to verify a module.
 bool VerifyModule(llvm::Module *module);

lib/AST/ASTBuilder.cpp

@@ -442,4 +442,12 @@ clang::ReturnStmt *ASTBuilder::CreateReturn(clang::Expr *retval) {
   return CreateReturnStmt(ctx, retval);
 }
 
+clang::TypedefDecl *ASTBuilder::CreateTypedefDecl(clang::DeclContext *decl_ctx,
+                                                  clang::IdentifierInfo *id,
+                                                  clang::QualType type) {
+  return clang::TypedefDecl::Create(ctx, decl_ctx, clang::SourceLocation(),
+                                    clang::SourceLocation(), id,
+                                    ctx.getTrivialTypeSourceInfo(type));
+}
+
 }  // namespace rellic

lib/AST/ASTPrinter.cpp

@@ -531,6 +531,26 @@ void DeclTokenizer::VisitRecordDecl(clang::RecordDecl *rdecl) {
   }
 }
 
+void DeclTokenizer::VisitTypedefDecl(clang::TypedefDecl *decl) {
+  auto &policy{unit.getASTContext().getPrintingPolicy()};
+  if (!policy.SuppressSpecifiers) {
+    out.push_back(Token::CreateMisc("typedef"));
+    Space();
+
+    if (decl->isModulePrivate()) {
+      out.push_back(Token::CreateMisc("__module_private__ "));
+    }
+  }
+  clang::QualType type = decl->getTypeSourceInfo()->getType();
+
+  std::string buf{""};
+  llvm::raw_string_ostream ss(buf);
+  type.print(ss, policy, decl->getName(), indent_level);
+
+  out.push_back(Token::CreateDecl(decl, ss.str()));
+  PrintAttributes(decl);
+}
+
 void StmtTokenizer::Space() { SpaceImpl(out); }
 void StmtTokenizer::Indent() { IndentImpl(out, indent_level); }
 void StmtTokenizer::Newline() { NewlineImpl(out); }

lib/AST/DebugInfoCollector.cpp

@@ -32,6 +32,26 @@ void DebugInfoCollector::visitDbgDeclareInst(llvm::DbgDeclareInst& inst) {
   WalkType(loc->getType(), var->getType());
 }
 
+void DebugInfoCollector::visitModule(llvm::Module& module) {
+  for (auto& gvar : module.globals()) {
+    llvm::SmallVector<llvm::DIGlobalVariableExpression*> gves;
+    gvar.getDebugInfo(gves);
+    auto ptrtype{gvar.getType()};
+    CHECK_LE(gves.size(), 1)
+        << "More than one DIGlobalVariableExpression for global variable";
+
+    if (gves.size() > 0) {
+      auto digve{gves[0]};
+      auto digvar{digve->getVariable()};
+      names[&gvar] = digvar->getName().str();
+      scopes[&gvar] = digvar->getScope();
+      valtypes[&gvar] = digvar->getType();
+
+      WalkType(ptrtype->getElementType(), digvar->getType());
+    }
+  }
+}
+
 void DebugInfoCollector::visitInstruction(llvm::Instruction& inst) {
   if (auto loc{inst.getDebugLoc().get()}) {
     scopes[&inst] = loc->getScope();
@@ -88,7 +108,8 @@ void DebugInfoCollector::WalkType(llvm::Type* type, llvm::DIType* ditype) {
       std::copy(params.begin(), params.end(), std::back_inserter(type_array));
 
       auto di_types{funcditype->getTypeArray()};
-      if (type_array.size() != di_types.size()) {
+      ret_types[functype] = di_types[0];
+      if (type_array.size() + functype->isVarArg() != di_types.size()) {
         // Mismatch between bitcode and debug metadata, bail out
         break;
       }
@@ -139,16 +160,15 @@ void DebugInfoCollector::visitFunction(llvm::Function& func) {
   }
 
   auto ditype{subprogram->getType()};
-
-  if (func.arg_size() + 1 != ditype->getTypeArray().size()) {
+  auto type_array{ditype->getTypeArray()};
+  if (func.arg_size() + func.isVarArg() + 1 != type_array.size()) {
     // Debug metadata is not compatible with bitcode, bail out
     // TODO(frabert): Find a way to reconcile differences
     return;
   }
 
   funcs[&func] = ditype;
   size_t i{1};
-  auto type_array{ditype->getTypeArray()};
   for (auto& arg : func.args()) {
     auto argtype{type_array[i++]};
     args[&arg] = argtype;

lib/AST/GenerateAST.cpp

@@ -367,10 +367,10 @@ clang::CompoundStmt *GenerateAST::StructureRegion(llvm::Region *region) {
 
 char GenerateAST::ID = 0;
 
-GenerateAST::GenerateAST(clang::ASTUnit &unit)
+GenerateAST::GenerateAST(clang::ASTUnit &unit, DebugInfoCollector &dic)
     : ModulePass(GenerateAST::ID),
       ast_ctx(&unit.getASTContext()),
-      ast_gen(unit),
+      ast_gen(unit, dic),
       ast(unit) {}
 
 void GenerateAST::getAnalysisUsage(llvm::AnalysisUsage &usage) const {