Remove some stack scratch buffers that are unneeded now (as we can no…

…w convert the SString itself and in some cases it was already in UTF8) and implement PR feedback.

src/coreclr/vm/array.cpp

@@ -402,8 +402,7 @@ MethodTable* Module::CreateArrayMethodTable(TypeHandle elemTypeHnd, CorElementTy
             StackSString ssElemName;
             elemTypeHnd.GetName(ssElemName);
 
-            StackScratchBuffer scratch;
-            elemTypeHnd.GetAssembly()->ThrowTypeLoadException(ssElemName.GetUTF8(scratch), IDS_CLASSLOAD_VALUECLASSTOOLARGE);
+            elemTypeHnd.GetAssembly()->ThrowTypeLoadException(ssElemName.GetUTF8(), IDS_CLASSLOAD_VALUECLASSTOOLARGE);
         }
     }
 
@@ -510,8 +509,7 @@ MethodTable* Module::CreateArrayMethodTable(TypeHandle elemTypeHnd, CorElementTy
 #ifdef _DEBUG
     StackSString debugName;
     TypeString::AppendType(debugName, TypeHandle(pMT));
-    StackScratchBuffer buff;
-    const char* pDebugNameUTF8 = debugName.GetUTF8(buff);
+    const char* pDebugNameUTF8 = debugName.GetUTF8();
     S_SIZE_T safeLen = S_SIZE_T(strlen(pDebugNameUTF8))+S_SIZE_T(1);
     if(safeLen.IsOverflow()) COMPlusThrowHR(COR_E_OVERFLOW);
     size_t len = safeLen.Value();
@@ -657,8 +655,7 @@ MethodTable* Module::CreateArrayMethodTable(TypeHandle elemTypeHnd, CorElementTy
                     StackSString ssElemName;
                     elemTypeHnd.GetName(ssElemName);
 
-                    StackScratchBuffer scratch;
-                    elemTypeHnd.GetAssembly()->ThrowTypeLoadException(ssElemName.GetUTF8(scratch),
+                    elemTypeHnd.GetAssembly()->ThrowTypeLoadException(ssElemName.GetUTF8(),
                                                                       IDS_CLASSLOAD_VALUECLASSTOOLARGE);
                 }
 

src/coreclr/vm/assembly.cpp

@@ -1004,8 +1004,7 @@ Module *Assembly::FindModuleByName(LPCSTR pszModuleName)
     SString moduleName(SString::Utf8, pszModuleName);
     moduleName.LowerCase();
 
-    StackScratchBuffer buffer;
-    pszModuleName = moduleName.GetUTF8(buffer);
+    pszModuleName = moduleName.GetUTF8();
 
     mdFile kFile = GetManifestFileToken(pszModuleName);
     if (kFile == mdTokenNil)

src/coreclr/vm/assemblynative.cpp

@@ -75,7 +75,7 @@ extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* p
     if (pAssemblyNameParts->_pName == NULL)
         COMPlusThrow(kArgumentException, W("Format_StringZeroLength"));
 
-    StackSString ssName(SString::Literal, pAssemblyNameParts->_pName);
+    StackSString ssName(pAssemblyNameParts->_pName);
 
     AssemblyMetaDataInternal asmInfo;
 
@@ -86,7 +86,7 @@ extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* p
 
     SmallStackSString ssLocale;
     if (pAssemblyNameParts->_pCultureName != NULL)
-        ssLocale.SetLiteral(pAssemblyNameParts->_pCultureName);
+        ssLocale.Set(pAssemblyNameParts->_pCultureName);
     asmInfo.szLocale = (pAssemblyNameParts->_pCultureName != NULL) ? ssLocale.GetUTF8() : NULL;
 
     // Initialize spec

src/coreclr/vm/classhash.cpp

@@ -205,14 +205,12 @@ static void ConstructKeyFromDataCaseInsensitive(EEClassHashTable::ConstructKeyCa
     StackSString nameSpace(SString::Utf8, pszNameSpace);
     nameSpace.LowerCase();
 
-    StackScratchBuffer nameSpaceBuffer;
-    Key[0] = (LPUTF8)nameSpace.GetUTF8(nameSpaceBuffer);
+    Key[0] = (LPUTF8)nameSpace.GetUTF8();
 
     StackSString name(SString::Utf8, pszName);
     name.LowerCase();
 
-    StackScratchBuffer nameBuffer;
-    Key[1] = (LPUTF8)name.GetUTF8(nameBuffer);
+    Key[1] = (LPUTF8)name.GetUTF8();
 
     pCallback->UseKeys(Key);
 }

src/coreclr/vm/clsload.cpp

@@ -1796,15 +1796,13 @@ VOID ClassLoader::CreateCanonicallyCasedKey(LPCUTF8 pszNameSpace, LPCUTF8 pszNam
     StackSString nameSpace(SString::Utf8, pszNameSpace);
     nameSpace.LowerCase();
 
-    StackScratchBuffer nameSpaceBuffer;
-    pszNameSpace = nameSpace.GetUTF8(nameSpaceBuffer);
+    pszNameSpace = nameSpace.GetUTF8();
 
 
     StackSString name(SString::Utf8, pszName);
     name.LowerCase();
 
-    StackScratchBuffer nameBuffer;
-    pszName = name.GetUTF8(nameBuffer);
+    pszName = name.GetUTF8();
 
 
    size_t iNSLength = strlen(pszNameSpace);

src/coreclr/vm/codepitchingmanager.cpp

@@ -232,9 +232,8 @@ static void LookupOrCreateInPitchingCandidate(MethodDesc* pMD, ULONG sizeOfCode)
             SString className, methodName, methodSig;
             pMD->GetMethodInfo(className, methodName, methodSig);
 
-            StackScratchBuffer scratch;
-            const char* szClassName = className.GetUTF8(scratch);
-            const char* szMethodSig = methodSig.GetUTF8(scratch);
+            const char* szClassName = className.GetUTF8();
+            const char* szMethodSig = methodSig.GetUTF8();
 
             printf("Candidate %lu %s :: %s %s\n",
                    sizeOfCode, szClassName, pMD->GetName(), szMethodSig);

src/coreclr/vm/comdelegate.cpp

@@ -925,8 +925,7 @@ FCIMPL5(FC_BOOL_RET, COMDelegate::BindToMethodName,
 
     // get the name in UTF8 format
     SString wszName(SString::Literal, gc.methodName->GetBuffer());
-    StackScratchBuffer utf8Name;
-    LPCUTF8 szNameStr = wszName.GetUTF8(utf8Name);
+    LPCUTF8 szNameStr = wszName.GetUTF8();
 
     // pick a proper compare function
     typedef int (__cdecl *UTF8StringCompareFuncPtr)(const char *, const char *);

src/coreclr/vm/coreassemblyspec.cpp

@@ -185,7 +185,7 @@ extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyName
 
     BEGIN_QCALL;
 
-    StackSString ssName(SString::Literal, pAssemblyNameParts->_pName);
+    StackSString ssName(pAssemblyNameParts->_pName);
 
     AssemblyMetaDataInternal asmInfo;
 
@@ -196,7 +196,7 @@ extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyName
 
     SmallStackSString ssLocale;
     if (pAssemblyNameParts->_pCultureName != NULL)
-        ssLocale.SetLiteral(pAssemblyNameParts->_pCultureName);
+        ssLocale.Set(pAssemblyNameParts->_pCultureName);
     asmInfo.szLocale = (pAssemblyNameParts->_pCultureName != NULL) ? ssLocale.GetUTF8() : NULL;
 
     // Initialize spec

src/coreclr/vm/corhost.cpp

@@ -426,15 +426,13 @@ HRESULT CorHost2::ExecuteInDefaultAppDomain(LPCWSTR pwzAssemblyPath,
         Assembly *pAssembly = AssemblySpec::LoadAssembly(pwzAssemblyPath);
 
         SString szTypeName(pwzTypeName);
-        StackScratchBuffer buff1;
-        const char* szTypeNameUTF8 = szTypeName.GetUTF8(buff1);
+        const char* szTypeNameUTF8 = szTypeName.GetUTF8();
         MethodTable *pMT = ClassLoader::LoadTypeByNameThrowing(pAssembly,
                                                             NULL,
                                                             szTypeNameUTF8).AsMethodTable();
 
         SString szMethodName(pwzMethodName);
-        StackScratchBuffer buff;
-        const char* szMethodNameUTF8 = szMethodName.GetUTF8(buff);
+        const char* szMethodNameUTF8 = szMethodName.GetUTF8();
         MethodDesc *pMethodMD = MemberLoader::FindMethod(pMT, szMethodNameUTF8, &gsig_SM_Str_RetInt);
 
         if (!pMethodMD)

src/coreclr/vm/customattribute.cpp

@@ -33,9 +33,8 @@ TypeHandle Attribute::GetTypeForEnum(LPCUTF8 szEnumName, COUNT_T cbEnumName, Dom
     }
     CONTRACTL_END;
 
-    StackScratchBuffer buff;
     StackSString sszEnumName(SString::Utf8, szEnumName, cbEnumName);
-    return TypeName::GetTypeUsingCASearchRules(sszEnumName.GetUTF8(buff), pDomainAssembly->GetAssembly());
+    return TypeName::GetTypeUsingCASearchRules(sszEnumName.GetUTF8(), pDomainAssembly->GetAssembly());
 }
 
 /*static*/

src/coreclr/vm/gdbjit.cpp

@@ -512,8 +512,7 @@ GetDebugInfoFromPDB(MethodDesc* methodDescPtr,
     if (modName.IsEmpty())
         return E_FAIL;
 
-    StackScratchBuffer scratch;
-    const char* szModName = modName.GetUTF8(scratch);
+    const char* szModName = modName.GetUTF8();
 
     MethodDebugInfo methodDebugInfo(numMap, locals.countVars);
 
@@ -956,8 +955,7 @@ void TypeInfoBase::CalculateName()
 
     TypeString::AppendType(sName, typeHandle, formatFlags);
 
-    StackScratchBuffer buffer;
-    const UTF8 *utf8 = sName.GetUTF8(buffer);
+    const UTF8 *utf8 = sName.GetUTF8();
     if (typeHandle.IsValueType())
     {
         m_type_name = new char[strlen(utf8) + 1];
@@ -1298,8 +1296,6 @@ void FunctionMember::DumpLinkageName(char* ptr, int& offset)
     md->GetMethodInfoNoSig(namespaceOrClassName, methodName);
     SString utf8namespaceOrClassName;
     SString utf8methodName;
-    namespaceOrClassName.ConvertToUTF8(utf8namespaceOrClassName);
-    methodName.ConvertToUTF8(utf8methodName);
 
     const char *nspace = utf8namespaceOrClassName.GetUTF8();
     const char *mname = utf8methodName.GetUTF8();
@@ -2538,8 +2534,7 @@ void NotifyGdb::OnMethodPrepared(MethodDesc* methodDescPtr)
     /* Get module name */
     const Module* mod = methodDescPtr->GetMethodTable()->GetModule();
     SString modName = mod->GetFile()->GetPath();
-    StackScratchBuffer scratch;
-    const char* szModName = modName.GetUTF8(scratch);
+    const char* szModName = modName.GetUTF8();
     const char* szModuleFile = SplitFilename(szModName);
 
     int length = MultiByteToWideChar(CP_UTF8, 0, szModuleFile, -1, NULL, 0);

src/coreclr/vm/generics.cpp

@@ -187,9 +187,8 @@ ClassLoader::CreateTypeHandleForNonCanonicalGenericInstantiation(
         TypeString::AppendTypeKeyDebug(debugTypeKeyName, pTypeKey);
         LOG((LF_CLASSLOADER, LL_INFO1000, "GENERICS: New instantiation requested: %S\n", debugTypeKeyName.GetUnicode()));
 
-        StackScratchBuffer buf;
-        if (g_pConfig->ShouldBreakOnInstantiation(debugTypeKeyName.GetUTF8(buf)))
-            CONSISTENCY_CHECK_MSGF(false, ("BreakOnInstantiation: typename '%s' ", debugTypeKeyName.GetUTF8(buf)));
+        if (g_pConfig->ShouldBreakOnInstantiation(debugTypeKeyName.GetUTF8()))
+            CONSISTENCY_CHECK_MSGF(false, ("BreakOnInstantiation: typename '%s' ", debugTypeKeyName.GetUTF8()));
     }
 #endif // _DEBUG
 
@@ -474,8 +473,7 @@ ClassLoader::CreateTypeHandleForNonCanonicalGenericInstantiation(
     // Name for debugging
     StackSString debug_ClassNameString;
     TypeString::AppendTypeKey(debug_ClassNameString, pTypeKey, TypeString::FormatNamespace | TypeString::FormatAngleBrackets | TypeString::FormatFullInst);
-    StackScratchBuffer debug_ClassNameBuffer;
-    const char *debug_szClassNameBuffer = debug_ClassNameString.GetUTF8(debug_ClassNameBuffer);
+    const char *debug_szClassNameBuffer = debug_ClassNameString.GetUTF8();
     S_SIZE_T safeLen = S_SIZE_T(strlen(debug_szClassNameBuffer)) + S_SIZE_T(1);
     if (safeLen.IsOverflow()) COMPlusThrowHR(COR_E_OVERFLOW);
 

src/coreclr/vm/jitinterface.cpp

@@ -12928,11 +12928,10 @@ PCODE UnsafeJitFunction(PrepareCodeConfig* config,
 
                 SString moduleName;
                 ftn->GetModule()->GetDomainAssembly()->GetPEAssembly()->GetPathOrCodeBase(moduleName);
-                MAKE_UTF8PTR_FROMWIDE(moduleNameUtf8, moduleName.GetUnicode());
 
                 SString codeBase;
                 codeBase.AppendPrintf("%s,0x%x,%d,%d\n",
-                                 moduleNameUtf8, //module name
+                                 moduleName.GetUTF8(), //module name
                                  ftn->GetMemberDef(), //method token
                                  (unsigned)(methodJitTimeStop.QuadPart - methodJitTimeStart.QuadPart), //cycle count
                                  methodInfo.ILCodeSize //il size

src/coreclr/vm/method.cpp

@@ -353,17 +353,15 @@ VOID MethodDesc::GetFullMethodInfo(SString& fullMethodSigName)
     PCCOR_SIGNATURE pSig;
 
     SString methodFullName;
-    StackScratchBuffer namespaceNameBuffer, methodNameBuffer;
     methodFullName.AppendPrintf(
         (LPCUTF8)"[%s] %s::%s",
         GetModule()->GetAssembly()->GetSimpleName(),
-        namespaceOrClassName.GetUTF8(namespaceNameBuffer),
-        methodName.GetUTF8(methodNameBuffer));
+        namespaceOrClassName.GetUTF8(),
+        methodName.GetUTF8());
 
     GetSig(&pSig, &cSig);
 
-    StackScratchBuffer buffer;
-    PrettyPrintSig(pSig, (DWORD)cSig, methodFullName.GetUTF8(buffer), &qbOut, GetMDImport(), NULL);
+    PrettyPrintSig(pSig, (DWORD)cSig, methodFullName.GetUTF8(), &qbOut, GetMDImport(), NULL);
     fullMethodSigName.AppendUTF8((char *)qbOut.Ptr());
 }
 

src/coreclr/vm/methodtablebuilder.cpp

@@ -1349,8 +1349,7 @@ MethodTableBuilder::BuildMethodTableThrowing(
     {
         StackSString debugName(SString::Utf8, GetDebugClassName());
         TypeString::AppendInst(debugName, bmtGenerics->GetInstantiation(), TypeString::FormatBasic);
-        StackScratchBuffer buff;
-        const char* pDebugNameUTF8 = debugName.GetUTF8(buff);
+        const char* pDebugNameUTF8 = debugName.GetUTF8();
         S_SIZE_T safeLen = S_SIZE_T(strlen(pDebugNameUTF8)) + S_SIZE_T(1);
         if(safeLen.IsOverflow())
             COMPlusThrowHR(COR_E_OVERFLOW);

src/coreclr/vm/mlinfo.cpp

@@ -2067,9 +2067,8 @@ MarshalInfo::MarshalInfo(Module* pModule,
                                 {
                                     // Load the type. Use an SString for the string since we need to NULL terminate the string
                                     // that comes from the metadata.
-                                    StackScratchBuffer utf8Name;
                                     SString safeArrayUserDefTypeName(SString::Utf8, ParamInfo.m_strSafeArrayUserDefTypeName, ParamInfo.m_cSafeArrayUserDefTypeNameBytes);
-                                    thElement = TypeName::GetTypeUsingCASearchRules(safeArrayUserDefTypeName.GetUTF8(utf8Name), pAssembly);
+                                    thElement = TypeName::GetTypeUsingCASearchRules(safeArrayUserDefTypeName.GetUTF8(), pAssembly);
                                 }
                             }
                             else

src/coreclr/vm/multicorejit.cpp

@@ -309,10 +309,9 @@ bool RecorderModuleInfo::SetModule(Module * pMod)
     simpleName.Set((const BYTE *) pModuleName, lenModuleName); // SBuffer::Set copies over name
 
     SString sAssemblyName;
-    StackScratchBuffer scratch;
     pMod->GetAssembly()->GetPEAssembly()->GetDisplayName(sAssemblyName);
 
-    LPCUTF8 pAssemblyName = sAssemblyName.GetUTF8(scratch);
+    LPCUTF8 pAssemblyName = sAssemblyName.GetUTF8();
     unsigned lenAssemblyName = sAssemblyName.GetCount();
     assemblyName.Set((const BYTE *) pAssemblyName, lenAssemblyName);
 

src/coreclr/vm/nativelibrary.cpp

@@ -707,8 +707,7 @@ namespace
                 SString moduleName(SString::Utf8, szLibName);
                 moduleName.LowerCase();
 
-                StackScratchBuffer buffer;
-                szLibName = (LPSTR)moduleName.GetUTF8(buffer);
+                szLibName = (LPSTR)moduleName.GetUTF8();
 
                 Assembly *pAssembly = spec.LoadAssembly(FILE_LOADED);
                 Module *pModule = pAssembly->FindModuleByName(szLibName);

src/coreclr/vm/pgo.cpp

@@ -220,10 +220,8 @@ void PgoManager::WritePgoData()
         SString tClass, tMethodName, tMethodSignature;
         pgoData->header.method->GetMethodInfo(tClass, tMethodName, tMethodSignature);
 
-        StackScratchBuffer nameBuffer;
-        StackScratchBuffer nameBuffer2;
-        fprintf(pgoDataFile, "MethodName: %s.%s\n", tClass.GetUTF8(nameBuffer), tMethodName.GetUTF8(nameBuffer2));
-        fprintf(pgoDataFile, "Signature: %s\n", tMethodSignature.GetUTF8(nameBuffer));
+        fprintf(pgoDataFile, "MethodName: %s.%s\n", tClass.GetUTF8(), tMethodName.GetUTF8());
+        fprintf(pgoDataFile, "Signature: %s\n", tMethodSignature.GetUTF8());
 
         uint8_t* data = pgoData->header.GetData();
 
@@ -262,15 +260,14 @@ void PgoManager::WritePgoData()
                             else
                             {
                                 StackSString ss;
-                                StackScratchBuffer nameBuffer;
                                 TypeString::AppendType(ss, th, TypeString::FormatNamespace | TypeString::FormatFullInst | TypeString::FormatAssembly);
                                 if (ss.GetCount() > 8192)
                                 {
                                     fprintf(pgoDataFile, s_TypeHandle, "UNKNOWN");
                                 }
                                 else
                                 {
-                                    fprintf(pgoDataFile, s_TypeHandle, ss.GetUTF8(nameBuffer));
+                                    fprintf(pgoDataFile, s_TypeHandle, ss.GetUTF8());
                                 }
                             }
                             break;
@@ -301,9 +298,7 @@ void PgoManager::WritePgoData()
                                 }
                                 else
                                 {
-                                    StackScratchBuffer methodNameBuffer;
-                                    StackScratchBuffer typeBuffer;
-                                    fprintf(pgoDataFile, "MethodHandle: %s|@|%s\n", tMethodName.GetUTF8(methodNameBuffer), tTypeName.GetUTF8(typeBuffer));
+                                    fprintf(pgoDataFile, "MethodHandle: %s|@|%s\n", tMethodName.GetUTF8(), tTypeName.GetUTF8());
                                 }
                             }
                             break;

src/coreclr/vm/stubgen.cpp

@@ -106,10 +106,7 @@ void ILStubLinker::DumpIL_FormatToken(mdToken token, SString &strTokenFormatting
             SString typeName;
             TypeString::AppendType(typeName, TypeHandle(pFD->GetApproxEnclosingMethodTable()));
 
-            SString typeNameUtf8;
-            typeName.ConvertToUTF8(typeNameUtf8);
-            SString strFieldName(SString::Utf8, pFD->GetName());
-            strTokenFormatting.Printf("%s::%s", typeNameUtf8.GetUTF8(), strFieldName.GetUTF8());
+            strTokenFormatting.Printf("%s::%s", typeName.GetUTF8(), pFD->GetName());
         }
         else if (TypeFromToken(token) == mdtModule)
         {

src/coreclr/vm/typeparse.cpp

@@ -1303,8 +1303,7 @@ TypeName::GetTypeHaveAssemblyHelper(
             if (bIgnoreCase)
                 name.LowerCase();
 
-            StackScratchBuffer buffer;
-            typeName.SetName(name.GetUTF8(buffer));
+            typeName.SetName(name.GetUTF8());
 
             // typeName.m_pBucket gets set here if the type is found
             // it will be used in the next iteration to look up the nested type