[CodeView] Implement function-type indices

[majnemer]

• Small cleanup

[rnk]

Test? You can probably update types-basic.ll, since it has functions in it already.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

961

FIXME to deal with instance methods

976

FIXME about pushing DW_AT_calling_convention through the metadata

[majnemer]

• Address review comments

[aaboud]

Few comments below.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

517–521

1. You may use "auto *SP" (like in line 443) instead of "const DISubprogram *".
2. Can you explain why we might emit debug info for functions that have no DISubprogram attached to it?

518

I thought we wanted to have the index of FuncIdRecord, not the index of ProcedureRecord, right?
Check line 128.

[majnemer]

• Address review comments

[rnk]

woot lgtm

[aaboud]

LGTM.
Only one comment (you might want to fix it in a follow up commit).

llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

129 ↗

(On Diff #59416)

Should not we return TypeIndex(0) in this case?
Or even better TypeIndex::None(), where:
static TypeIndex None() { return TypeIndex(SimpleTypeKind::None); }

lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   /// section starts with the magic version number on first use. If GVSym is
   /// null, uses the main .debug$S section.
   void switchToDebugSectionForSymbol(const MCSymbol *GVSym);
 
   /// The next available function index for use with our .cv_* directives. Not
   /// to be confused with type indices for LF_FUNC_ID records.
   unsigned NextFuncId = 0;
 
-  codeview::TypeIndex VoidFnTyIdx;
-
-  /// Get a type index for a generic void function type.
-  codeview::TypeIndex getGenericFunctionTypeIndex();
+  codeview::TypeIndex
+  getFunctionTypeIndex(const DISubroutineType *SubroutineTy);
 
   InlineSite &getInlineSite(const DILocation *InlinedAt,
                             const DISubprogram *Inlinee);
 
   void recordFuncIdForSubprogram(const DISubprogram *SP);
 
   static void collectInlineSiteChildren(SmallVectorImpl<unsigned> &Children,
                                         const FunctionInfo &FI,

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

if (SiteInsertion.second) {
     Site->SiteFuncId = NextFuncId++;
     Site->Inlinee = Inlinee;
     InlinedSubprograms.insert(Inlinee);
     recordFuncIdForSubprogram(Inlinee);
   }
   return *Site;
 }
 
-TypeIndex CodeViewDebug::getGenericFunctionTypeIndex() {
-  if (VoidFnTyIdx.getIndex() != 0)
-    return VoidFnTyIdx;
+TypeIndex
+CodeViewDebug::getFunctionTypeIndex(const DISubroutineType *SubroutineTy) {
+  // Check if we've already translated this type.
+  auto I = TypeIndices.find(SubroutineTy);
+  if (I != TypeIndices.end())
+    return I->second;
+
+  SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
+  for (DITypeRef ArgTypeRef : SubroutineTy->getTypeArray())
+    ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
+
+  TypeIndex ReturnTypeIndex = TypeIndex::Void();
+  ArrayRef<TypeIndex> ArgTypeIndices = None;
+  if (!ReturnAndArgTypeIndices.empty()) {
+    auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
+    ReturnTypeIndex = ReturnAndArgTypesRef.front();
+    ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
+  }
 
-  ArrayRef<TypeIndex> NoArgs;
-  ArgListRecord ArgListRec(TypeRecordKind::ArgList, NoArgs);
+  ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
   TypeIndex ArgListIndex = TypeTable.writeArgList(ArgListRec);
 
-  ProcedureRecord Procedure(TypeIndex::Void(), CallingConvention::NearC,
+  ProcedureRecord Procedure(ReturnTypeIndex, CallingConvention::NearC,
                             FunctionOptions::None, 0, ArgListIndex);
-  VoidFnTyIdx = TypeTable.writeProcedure(Procedure);
-  return VoidFnTyIdx;
+  TypeIndex TI = TypeTable.writeProcedure(Procedure);
+
+  auto InsertResult = TypeIndices.insert({SubroutineTy, TI});
+  (void)InsertResult;
+  assert(InsertResult.second && "DISubroutineType lowered twice");
+  return TI;
 }
 
 void CodeViewDebug::recordFuncIdForSubprogram(const DISubprogram *SP) {
   TypeIndex ParentScope = TypeIndex(0);
   StringRef DisplayName = SP->getDisplayName();
-  FuncIdRecord FuncId(ParentScope, getGenericFunctionTypeIndex(), DisplayName);
+  FuncIdRecord FuncId(ParentScope, getFunctionTypeIndex(SP->getType()),
+                      DisplayName);
   TypeIndex TI = TypeTable.writeFuncId(FuncId);
   TypeIndices[SP] = TI;
 }
 
 void CodeViewDebug::recordLocalVariable(LocalVariable &&Var,
                                         const DILocation *InlinedAt) {
   if (InlinedAt) {
     // This variable was inlined. Associate it with the InlineSite.
OS.EmitLabel(SymbolsBegin);
     // code is located and what's its size:
     OS.AddComment("Code size");
     OS.emitAbsoluteSymbolDiff(FI.End, Fn, 4);
     OS.AddComment("Offset after prologue");
     OS.EmitIntValue(0, 4);
     OS.AddComment("Offset before epilogue");
     OS.EmitIntValue(0, 4);
     OS.AddComment("Function type index");
+    if (const DISubprogram *Subprogram = GV->getSubprogram())
+      OS.EmitIntValue(getFunctionTypeIndex(Subprogram->getType()).getIndex(),
+                      4);
+    else
       OS.EmitIntValue(0, 4);
     OS.AddComment("Function section relative address");
     OS.EmitCOFFSecRel32(Fn);
     OS.AddComment("Function section index");
     OS.EmitCOFFSectionIndex(Fn);
     OS.AddComment("Flags");
     OS.EmitIntValue(0, 1);
     // Emit the function display name as a null-terminated string.
     OS.AddComment("Function name");
if (IsModifier)
       BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType().resolve();
   }
   TypeIndex ModifiedTI = getTypeIndex(BaseTy);
   ModifierRecord MR(ModifiedTI, Mods);
   return TypeTable.writeModifier(MR);
 }
 
 TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef) {
   const DIType *Ty = TypeRef.resolve();
 
   // The null DIType is the void type. Don't try to hash it.
   if (!Ty)
     return TypeIndex::Void();
 
   // Check if we've already translated this type.
   auto I = TypeIndices.find(Ty);
   if (I != TypeIndices.end())
     return I->second;
 
   TypeIndex TI = lowerType(Ty);
 
   auto InsertResult = TypeIndices.insert({Ty, TI});
   (void)InsertResult;
   assert(InsertResult.second && "DIType lowered twice");
   return TI;
 }
 
 void CodeViewDebug::emitLocalVariable(const LocalVariable &Var) {
   // LocalSym record, see SymbolRecord.h for more info.
   MCSymbol *LocalBegin = MMI->getContext().createTempSymbol(),
            *LocalEnd = MMI->getContext().createTempSymbol();
   OS.AddComment("Record length");