Implement getClassAssemblyName (dotnet#106959)

* Add getClassAssemblyName

* Handle nullptrs

* Remove CORINFO_ASSEMBLY_HANDLE

* Address feedbacks

Co-authored-by: Jan Kotas <jkotas@microsoft.com>

src/coreclr/inc/corinfo.h

@@ -930,7 +930,6 @@ struct PatchpointInfo;
 // Cookie types consumed by the code generator (these are opaque values
 // not inspected by the code generator):
 
-typedef struct CORINFO_ASSEMBLY_STRUCT_* CORINFO_ASSEMBLY_HANDLE;
 typedef struct CORINFO_MODULE_STRUCT_* CORINFO_MODULE_HANDLE;
 typedef struct CORINFO_DEPENDENCY_STRUCT_* CORINFO_DEPENDENCY_HANDLE;
 typedef struct CORINFO_CLASS_STRUCT_* CORINFO_CLASS_HANDLE;
@@ -2321,18 +2320,9 @@ class ICorStaticInfo
  CORINFO_CLASS_HANDLE cls
  ) = 0;
 
- virtual CORINFO_MODULE_HANDLE getClassModule (
- CORINFO_CLASS_HANDLE cls
- ) = 0;
-
- // Returns the assembly that contains the module "mod".
- virtual CORINFO_ASSEMBLY_HANDLE getModuleAssembly (
- CORINFO_MODULE_HANDLE mod
- ) = 0;
-
- // Returns the name of the assembly "assem".
- virtual const char* getAssemblyName (
- CORINFO_ASSEMBLY_HANDLE assem
+ // Returns the assembly name of the class "cls", or nullptr if there is none. 
+ virtual const char* getClassAssemblyName (
+ CORINFO_CLASS_HANDLE cls
  ) = 0;
 
  // Allocate and delete process-lifetime objects. Should only be

src/coreclr/inc/icorjitinfoimpl_generated.h

@@ -193,15 +193,9 @@ bool isValueClass(
 uint32_t getClassAttribs(
  CORINFO_CLASS_HANDLE cls) override;
 
-CORINFO_MODULE_HANDLE getClassModule(
+const char* getClassAssemblyName(
  CORINFO_CLASS_HANDLE cls) override;
 
-CORINFO_ASSEMBLY_HANDLE getModuleAssembly(
- CORINFO_MODULE_HANDLE mod) override;
-
-const char* getAssemblyName(
- CORINFO_ASSEMBLY_HANDLE assem) override;
-
 void* LongLifetimeMalloc(
  size_t sz) override;
 

src/coreclr/inc/jiteeversionguid.h

@@ -43,11 +43,11 @@ typedef const GUID *LPCGUID;
 #define GUID_DEFINED
 #endif // !GUID_DEFINED
 
-constexpr GUID JITEEVersionIdentifier = { /* 7f7fd340-4779-455a-8046-628f3cd8c3c7 */
- 0x7f7fd340,
- 0x4779,
- 0x455a,
- {0x80, 0x46, 0x62, 0x8f, 0x3c, 0xd8, 0xc3, 0xc7}
+constexpr GUID JITEEVersionIdentifier = { /* b75a5475-ff22-4078-9551-2024ce03d383 */
+ 0xb75a5475,
+ 0xff22,
+ 0x4078,
+ {0x95, 0x51, 0x20, 0x24, 0xce, 0x03, 0xd3, 0x83}
  };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////

src/coreclr/jit/ICorJitInfo_names_generated.h

@@ -45,9 +45,7 @@ DEF_CLR_API(getTypeInstantiationArgument)
 DEF_CLR_API(printClassName)
 DEF_CLR_API(isValueClass)
 DEF_CLR_API(getClassAttribs)
-DEF_CLR_API(getClassModule)
-DEF_CLR_API(getModuleAssembly)
-DEF_CLR_API(getAssemblyName)
+DEF_CLR_API(getClassAssemblyName)
 DEF_CLR_API(LongLifetimeMalloc)
 DEF_CLR_API(LongLifetimeFree)
 DEF_CLR_API(getIsClassInitedFlagAddress)

src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp

@@ -416,30 +416,12 @@ uint32_t WrapICorJitInfo::getClassAttribs(
  return temp;
 }
 
-CORINFO_MODULE_HANDLE WrapICorJitInfo::getClassModule(
+const char* WrapICorJitInfo::getClassAssemblyName(
  CORINFO_CLASS_HANDLE cls)
 {
- API_ENTER(getClassModule);
- CORINFO_MODULE_HANDLE temp = wrapHnd->getClassModule(cls);
- API_LEAVE(getClassModule);
- return temp;
-}
-
-CORINFO_ASSEMBLY_HANDLE WrapICorJitInfo::getModuleAssembly(
- CORINFO_MODULE_HANDLE mod)
-{
- API_ENTER(getModuleAssembly);
- CORINFO_ASSEMBLY_HANDLE temp = wrapHnd->getModuleAssembly(mod);
- API_LEAVE(getModuleAssembly);
- return temp;
-}
-
-const char* WrapICorJitInfo::getAssemblyName(
- CORINFO_ASSEMBLY_HANDLE assem)
-{
- API_ENTER(getAssemblyName);
- const char* temp = wrapHnd->getAssemblyName(assem);
- API_LEAVE(getAssemblyName);
+ API_ENTER(getClassAssemblyName);
+ const char* temp = wrapHnd->getClassAssemblyName(cls);
+ API_LEAVE(getClassAssemblyName);
  return temp;
 }
 

src/coreclr/jit/compiler.cpp

@@ -2586,8 +2586,7 @@ void Compiler::compInitOptions(JitFlags* jitFlags)
  // We have an exclusion list. See if this method is in an assembly that is on the list.
  // Note that we check this for every method, since we might inline across modules, and
  // if the inlinee module is on the list, we don't want to use the altjit for it.
- const char* methodAssemblyName = info.compCompHnd->getAssemblyName(
- info.compCompHnd->getModuleAssembly(info.compCompHnd->getClassModule(info.compClassHnd)));
+ const char* methodAssemblyName = eeGetClassAssemblyName(info.compClassHnd);
  if (s_pAltJitExcludeAssembliesList->IsInList(methodAssemblyName))
  {
  opts.altJit = false;
@@ -2614,8 +2613,7 @@ void Compiler::compInitOptions(JitFlags* jitFlags)
  bool assemblyInIncludeList = true; // assume we'll dump, if there's not an include list (or it's empty).
  if (s_pJitDisasmIncludeAssembliesList != nullptr && !s_pJitDisasmIncludeAssembliesList->IsEmpty())
  {
- const char* assemblyName = info.compCompHnd->getAssemblyName(
- info.compCompHnd->getModuleAssembly(info.compCompHnd->getClassModule(info.compClassHnd)));
+ const char* assemblyName = eeGetClassAssemblyName(info.compClassHnd);
  if (!s_pJitDisasmIncludeAssembliesList->IsInList(assemblyName))
  {
  // We have a list, and the current assembly is not in it, so we won't dump.
@@ -6335,39 +6333,29 @@ int Compiler::compCompile(CORINFO_MODULE_HANDLE classPtr,
 #ifdef DEBUG
  if (JitConfig.EnableExtraSuperPmiQueries())
  {
- // This call to getClassModule/getModuleAssembly/getAssemblyName fails in crossgen2 due to these
- // APIs being unimplemented. So disable this extra info for pre-jit mode. See
- // https://github.com/dotnet/runtime/issues/48888.
- //
- // Ditto for some of the class name queries for generic params.
- //
- if (!compileFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
- {
- // Get the assembly name, to aid finding any particular SuperPMI method context function
- (void)info.compCompHnd->getAssemblyName(
- info.compCompHnd->getModuleAssembly(info.compCompHnd->getClassModule(info.compClassHnd)));
+ // Get the assembly name, to aid finding any particular SuperPMI method context function
+ (void)eeGetClassAssemblyName(info.compClassHnd);
 
-  // Fetch class names for the method's generic parameters.
-  //
-  CORINFO_SIG_INFO sig;
-  info.compCompHnd->getMethodSig(info.compMethodHnd, &sig, nullptr);
+ // Fetch class names for the method's generic parameters.
+ //
+ CORINFO_SIG_INFO sig;
+ info.compCompHnd->getMethodSig(info.compMethodHnd, &sig, nullptr);
 
- const unsigned classInst = sig.sigInst.classInstCount;
- if (classInst > 0)
+ const unsigned classInst = sig.sigInst.classInstCount;
+ if (classInst > 0)
+ {
+ for (unsigned i = 0; i < classInst; i++)
  {
- for (unsigned i = 0; i < classInst; i++)
- {
- eeGetClassName(sig.sigInst.classInst[i]);
- }
+ eeGetClassName(sig.sigInst.classInst[i]);
  }
+ }
 
- const unsigned methodInst = sig.sigInst.methInstCount;
- if (methodInst > 0)
+ const unsigned methodInst = sig.sigInst.methInstCount;
+ if (methodInst > 0)
+ {
+ for (unsigned i = 0; i < methodInst; i++)
  {
- for (unsigned i = 0; i < methodInst; i++)
- {
- eeGetClassName(sig.sigInst.methInst[i]);
- }
+ eeGetClassName(sig.sigInst.methInst[i]);
  }
  }
  }
@@ -9221,8 +9209,7 @@ void JitTimer::PrintCsvMethodStats(Compiler* comp)
  }
  else
  {
- const char* methodAssemblyName = comp->info.compCompHnd->getAssemblyName(
- comp->info.compCompHnd->getModuleAssembly(comp->info.compCompHnd->getClassModule(comp->info.compClassHnd)));
+ const char* methodAssemblyName = comp->eeGetClassAssemblyName(comp->info.compClassHnd);
  fprintf(s_csvFile, "\"%s\",", methodAssemblyName);
  }
  fprintf(s_csvFile, "%u,", comp->info.compILCodeSize);

src/coreclr/jit/compiler.h

@@ -8337,6 +8337,8 @@ class Compiler
  void eePrintObjectDescription(const char* prefix, CORINFO_OBJECT_HANDLE handle);
  const char* eeGetShortClassName(CORINFO_CLASS_HANDLE clsHnd);
 
+ const char* eeGetClassAssemblyName(CORINFO_CLASS_HANDLE clsHnd);
+
 #if defined(DEBUG)
  unsigned eeTryGetClassSize(CORINFO_CLASS_HANDLE clsHnd);
 #endif

src/coreclr/jit/eeinterface.cpp

@@ -596,6 +596,27 @@ const char* Compiler::eeGetShortClassName(CORINFO_CLASS_HANDLE clsHnd)
  return printer.GetBuffer();
 }
 
+//------------------------------------------------------------------------
+// eeGetClassAssemblyName:
+// Get the assembly name of a type.
+// If missing information (in SPMI), then return a placeholder string.
+//
+// Parameters:
+// clsHnd - the handle of the class
+//
+// Return value:
+// The name string.
+//
+const char* Compiler::eeGetClassAssemblyName(CORINFO_CLASS_HANDLE clsHnd)
+{
+ const char* assemblyName = "<unknown assembly>";
+ eeRunFunctorWithSPMIErrorTrap([&]() {
+ assemblyName = info.compCompHnd->getClassAssemblyName(clsHnd);
+ });
+
+ return assemblyName != nullptr ? assemblyName : "<no assembly>";
+}
+
 void Compiler::eePrintObjectDescription(const char* prefix, CORINFO_OBJECT_HANDLE handle)
 {
  const size_t maxStrSize = 64;

src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs

@@ -2092,12 +2092,17 @@ private uint getClassAttribsInternal(TypeDesc type)
  return (uint)result;
  }
 
- private CORINFO_MODULE_STRUCT_* getClassModule(CORINFO_CLASS_STRUCT_* cls)
- { throw new NotImplementedException("getClassModule"); }
- private CORINFO_ASSEMBLY_STRUCT_* getModuleAssembly(CORINFO_MODULE_STRUCT_* mod)
- { throw new NotImplementedException("getModuleAssembly"); }
- private byte* getAssemblyName(CORINFO_ASSEMBLY_STRUCT_* assem)
- { throw new NotImplementedException("getAssemblyName"); }
+ private byte* getClassAssemblyName(CORINFO_CLASS_STRUCT_* cls)
+ {
+ TypeDesc type = HandleToObject(cls);
+
+ if (type is MetadataType mdType)
+ {
+ return (byte*)GetPin(StringToUTF8(mdType.Module.Assembly.GetName().Name));
+ }
+
+ return null;
+ }
 
 #pragma warning disable CA1822 // Mark members as static
  private void* LongLifetimeMalloc(UIntPtr sz)