[WebAssembly] Refactor ObjFile::initializeSymbols.

[ruiu]

Summary

The main purpose of this change is to make initializeSymbols shorter.

lld/trunk/wasm/InputFiles.h

public:
 
   ArrayRef<Symbol *> getSymbols() const { return Symbols; }
   Symbol *getSymbol(uint32_t Index) const { return Symbols[Index]; }
   FunctionSymbol *getFunctionSymbol(uint32_t Index) const;
   DataSymbol *getDataSymbol(uint32_t Index) const;
   GlobalSymbol *getGlobalSymbol(uint32_t Index) const;
 
 private:
-  Symbol *createDefinedData(const WasmSymbol &Sym, InputSegment *Segment,
-                            uint32_t Offset, uint32_t DataSize);
-  Symbol *createDefinedFunction(const WasmSymbol &Sym, InputFunction *Function);
-  Symbol *createDefinedGlobal(const WasmSymbol &Sym, InputGlobal *Global);
+  Symbol *createDefined(const WasmSymbol &Sym);
   Symbol *createUndefined(const WasmSymbol &Sym);
 
   void initializeSymbols();
   InputSegment *getSegment(const WasmSymbol &WasmSym) const;
   InputFunction *getFunction(const WasmSymbol &Sym) const;
   InputGlobal *getGlobal(const WasmSymbol &Sym) const;
   bool isExcludedByComdat(InputChunk *Chunk) const;
 

lld/trunk/wasm/InputFiles.cpp

for (size_t I = 0; I < Funcs.size(); ++I) {
     InputFunction *F = make<InputFunction>(Sig, &Func, this);
     F->copyRelocations(*CodeSection);
     Functions.emplace_back(F);
   }
 
   // Populate `Symbols` based on the WasmSymbols in the object
   for (const SymbolRef &Sym : WasmObj->symbols()) {
     const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
-    bool IsDefined = WasmSym.isDefined();
 
-    if (IsDefined) {
-      switch (WasmSym.Info.Kind) {
-      case WASM_SYMBOL_TYPE_FUNCTION: {
-        InputFunction *Function = getFunction(WasmSym);
-        if (isExcludedByComdat(Function)) {
-          Function->Live = false;
-          IsDefined = false;
-          break;
-        }
-        Symbols.push_back(createDefinedFunction(WasmSym, Function));
-        break;
-      }
-      case WASM_SYMBOL_TYPE_DATA: {
-        InputSegment *Segment = getSegment(WasmSym);
-        if (isExcludedByComdat(Segment)) {
-          Segment->Live = false;
-          IsDefined = false;
-          break;
-        }
-        Symbols.push_back(createDefinedData(WasmSym, Segment,
-                                            WasmSym.Info.DataRef.Offset,
-                                            WasmSym.Info.DataRef.Size));
-        break;
-      }
-      case WASM_SYMBOL_TYPE_GLOBAL:
-        Symbols.push_back(createDefinedGlobal(WasmSym, getGlobal(WasmSym)));
-        break;
-      default:
-        llvm_unreachable("unkown symbol kind");
-        break;
-      }
+    if (Symbol *Sym = createDefined(WasmSym))
+      Symbols.push_back(Sym);
+    else
+      Symbols.push_back(createUndefined(WasmSym));
+
+Symbol *ObjFile::createDefined(const WasmSymbol &Sym) {
+  if (!Sym.isDefined())
+    return nullptr;
+
+  switch (Sym.Info.Kind) {
+  case WASM_SYMBOL_TYPE_FUNCTION: {
+    InputFunction *Func = getFunction(Sym);
+    if (isExcludedByComdat(Func)) {
+      Func->Live = false;
+      return nullptr;
+
+    if (Sym.isBindingLocal())
+      return make<DefinedFunction>(Sym.Info.Name, Sym.Info.Flags, this, Func);
+    return Symtab->addDefinedFunction(Sym.Info.Name, Sym.Info.Flags, this,
+                                      Func);
+  case WASM_SYMBOL_TYPE_DATA: {
+    InputSegment *Seg = getSegment(Sym);
+    if (isExcludedByComdat(Seg)) {
+      Seg->Live = false;
+      return nullptr;
     }
 
-    // Either the the symbol itself was undefined, or was excluded via comdat
-    // in which case this simply insertes the existing symbol into the correct
-    // slot in the Symbols array.
-    if (!IsDefined)
-      Symbols.push_back(createUndefined(WasmSym));
+    uint32_t Offset = Sym.Info.DataRef.Offset;
+    uint32_t Size = Sym.Info.DataRef.Size;
+
+    if (Sym.isBindingLocal())
+      return make<DefinedData>(Sym.Info.Name, Sym.Info.Flags, this, Seg, Offset,
+                               Size);
+    return Symtab->addDefinedData(Sym.Info.Name, Sym.Info.Flags, this, Seg,
+                                  Offset, Size);
   }
+  case WASM_SYMBOL_TYPE_GLOBAL:
+    if (Sym.isBindingLocal())
+      return make<DefinedGlobal>(Sym.Info.Name, Sym.Info.Flags, this,
+                                 getGlobal(Sym));
+    return Symtab->addDefinedGlobal(Sym.Info.Name, Sym.Info.Flags, this,
+                                    getGlobal(Sym));
+  }
+  llvm_unreachable("unkown symbol kind");
 }
 
 Symbol *ObjFile::createUndefined(const WasmSymbol &Sym) {
   StringRef Name = Sym.Info.Name;
   uint32_t Flags = Sym.Info.Flags;
 
   switch (Sym.Info.Kind) {
   case WASM_SYMBOL_TYPE_FUNCTION:
     return Symtab->addUndefinedFunction(Name, Flags, this, Sym.FunctionType);
   case WASM_SYMBOL_TYPE_DATA:
     return Symtab->addUndefinedData(Name, Flags, this);
   case WASM_SYMBOL_TYPE_GLOBAL:
     return Symtab->addUndefinedGlobal(Name, Flags, this, Sym.GlobalType);
   }
   llvm_unreachable("unkown symbol kind");
 }
 
-Symbol *ObjFile::createDefinedFunction(const WasmSymbol &Sym,
-                                       InputFunction *Function) {
-  if (Sym.isBindingLocal())
-    return make<DefinedFunction>(Sym.Info.Name, Sym.Info.Flags, this, Function);
-  return Symtab->addDefinedFunction(Sym.Info.Name, Sym.Info.Flags, this,
-                                    Function);
-}
-
-Symbol *ObjFile::createDefinedData(const WasmSymbol &Sym, InputSegment *Segment,
-                                   uint32_t Offset, uint32_t Size) {
-  if (Sym.isBindingLocal())
-    return make<DefinedData>(Sym.Info.Name, Sym.Info.Flags, this, Segment,
-                             Offset, Size);
-  return Symtab->addDefinedData(Sym.Info.Name, Sym.Info.Flags, this, Segment,
-                                Offset, Size);
-}
-
-Symbol *ObjFile::createDefinedGlobal(const WasmSymbol &Sym,
-                                     InputGlobal *Global) {
-  if (Sym.isBindingLocal())
-    return make<DefinedGlobal>(Sym.Info.Name, Sym.Info.Flags, this, Global);
-  return Symtab->addDefinedGlobal(Sym.Info.Name, Sym.Info.Flags, this, Global);
-}
-
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
   File = CHECK(Archive::create(MB), toString(this));
 
   // Read the symbol table to construct Lazy symbols.
   int Count = 0;
   for (const Archive::Symbol &Sym : File->symbols()) {