[WebAssembly][MC] Use StringRef over std::string pointer

[sbc100]

Summary

This is followup based on feedback on 5be42f36f56.
See: https://reviews.llvm.org/D77627.

[dblaikie]

Looks good - thanks!

[bcain]

llvm/include/llvm/MC/MCSymbolWasm.h

87–89

This block could instead be written as return ImportName.getValueOr(getName());

[not that you need to revisit the code, just a suggestion for next time]

llvm/include/llvm/MC/MCSymbolWasm.h

 namespace llvm {
 
 class MCSymbolWasm : public MCSymbol {
   wasm::WasmSymbolType Type = wasm::WASM_SYMBOL_TYPE_DATA;
   bool IsWeak = false;
   bool IsHidden = false;
   bool IsComdat = false;
   mutable bool IsUsedInGOT = false;
+  Optional<StringRef> ImportModule;
+  Optional<StringRef> ImportName;
+  Optional<StringRef> ExportName;
+  wasm::WasmSignature *Signature = nullptr;
   Optional<wasm::WasmGlobalType> GlobalType;
   Optional<wasm::WasmEventType> EventType;
 
-  // Non-owning pointers since MCSymbol must be trivially destructible.
-  std::string *ImportModule = nullptr;
-  std::string *ImportName = nullptr;
-  std::string *ExportName = nullptr;
-  wasm::WasmSignature *Signature = nullptr;
-
   /// An expression describing how to calculate the size of a symbol. If a
   /// symbol has no size this field will be NULL.
   const MCExpr *SymbolSize = nullptr;
 
 public:
   MCSymbolWasm(const StringMapEntry<bool> *Name, bool isTemporary)
       : MCSymbol(SymbolKindWasm, Name, isTemporary) {}
   static bool classof(const MCSymbol *S) { return S->isWasm(); }
public:
   void setWeak(bool isWeak) { IsWeak = isWeak; }
 
   bool isHidden() const { return IsHidden; }
   void setHidden(bool isHidden) { IsHidden = isHidden; }
 
   bool isComdat() const { return IsComdat; }
   void setComdat(bool isComdat) { IsComdat = isComdat; }
 
-  bool hasImportModule() const { return ImportModule != nullptr; }
+  bool hasImportModule() const { return ImportModule.hasValue(); }
   const StringRef getImportModule() const {
-    if (ImportModule)
-      return StringRef(*ImportModule);
+    if (ImportModule.hasValue()) {
+      return ImportModule.getValue();
+    }
     // Use a default module name of "env" for now, for compatibility with
     // existing tools.
     // TODO(sbc): Find a way to specify a default value in the object format
     // without picking a hardcoded value like this.
     return "env";
   }
-  void setImportModule(std::string *Name) { ImportModule = Name; }
+  void setImportModule(StringRef Name) { ImportModule = Name; }
 
-  bool hasImportName() const { return ImportName != nullptr; }
+  bool hasImportName() const { return ImportName.hasValue(); }
   const StringRef getImportName() const {
-    if (ImportName)
-      return StringRef(*ImportName);
+    if (ImportName.hasValue()) {
+      return ImportName.getValue();
+    }
     return getName();
   }
-  void setImportName(std::string *Name) { ImportName = Name; }
+  void setImportName(StringRef Name) { ImportName = Name; }
 
-  bool hasExportName() const { return ExportName != nullptr; }
-  const StringRef getExportName() const {
-    assert(ExportName);
-    return StringRef(*ExportName);
-  }
-  void setExportName(std::string *Name) { ExportName = Name; }
+  bool hasExportName() const { return ExportName.hasValue(); }
+  const StringRef getExportName() const { return ExportName.getValue(); }
+  void setExportName(StringRef Name) { ExportName = Name; }
 
   void setUsedInGOT() const { IsUsedInGOT = true; }
   bool isUsedInGOT() const { return IsUsedInGOT; }
 
   const wasm::WasmSignature *getSignature() const { return Signature; }
   void setSignature(wasm::WasmSignature *Sig) { Signature = Sig; }
 
   const wasm::WasmGlobalType &getGlobalType() const {

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

#include "WebAssemblyGenAsmMatcher.inc"
   bool error(const Twine &Msg) {
     return Parser.Error(Lexer.getTok().getLoc(), Msg);
   }
 
   void addSignature(std::unique_ptr<wasm::WasmSignature> &&Sig) {
     Signatures.push_back(std::move(Sig));
   }
 
-  std::string *storeName(StringRef Name) {
+  StringRef storeName(StringRef Name) {
     std::unique_ptr<std::string> N = std::make_unique<std::string>(Name);
     Names.push_back(std::move(N));
-    return Names.back().get();
+    return *Names.back();
   }
 
   std::pair<StringRef, StringRef> nestingString(NestingType NT) {
     switch (NT) {
     case Function:
       return {"function", "end_function"};
     case Block:
       return {"block", "end_block"};

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.h

 class LLVM_LIBRARY_VISIBILITY WebAssemblyAsmPrinter final : public AsmPrinter {
   const WebAssemblySubtarget *Subtarget;
   const MachineRegisterInfo *MRI;
   WebAssemblyFunctionInfo *MFI;
   // TODO: Do the uniquing of Signatures here instead of ObjectFileWriter?
   std::vector<std::unique_ptr<wasm::WasmSignature>> Signatures;
   std::vector<std::unique_ptr<std::string>> Names;
 
-  std::string *storeName(StringRef Name) {
+  StringRef storeName(StringRef Name) {
     std::unique_ptr<std::string> N = std::make_unique<std::string>(Name);
     Names.push_back(std::move(N));
-    return Names.back().get();
+    return *Names.back();
   }
 
 public:
   explicit WebAssemblyAsmPrinter(TargetMachine &TM,
                                  std::unique_ptr<MCStreamer> Streamer)
       : AsmPrinter(TM, std::move(Streamer)), Subtarget(nullptr), MRI(nullptr),
         MFI(nullptr) {}