[WebAssembly] Add helper functions to WasmObjectFile.cpp

[sbc100]

Summary

Also, fix crash when exporting an imported function.

include/llvm/Object/Wasm.h

public:
   uint8_t getBytesInAddress() const override;
   StringRef getFileFormatName() const override;
   Triple::ArchType getArch() const override;
   SubtargetFeatures getFeatures() const override;
   bool isRelocatableObject() const override;
 
 private:
   bool isValidFunctionIndex(uint32_t Index) const;
+  bool isDefinedFunctionIndex(uint32_t Index) const;
+  wasm::WasmFunction& getDefinedFunction(uint32_t Index);
+
   const WasmSection &getWasmSection(DataRefImpl Ref) const;
   const wasm::WasmRelocation &getWasmRelocation(DataRefImpl Ref) const;
 
   WasmSection* findCustomSectionByName(StringRef Name);
   WasmSection* findSectionByType(uint32_t Type);
 
   const uint8_t *getPtr(size_t Offset) const;
   Error parseSection(WasmSection &Sec);

lib/Object/WasmObjectFile.cpp

case wasm::WASM_NAMES_FUNCTION: {
         if (!Seen.insert(Index).second)
           return make_error<GenericBinaryError>("Function named more than once",
                                                 object_error::parse_failed);
         StringRef Name = readString(Ptr);
         if (!isValidFunctionIndex(Index) || Name.empty())
           return make_error<GenericBinaryError>("Invalid name entry",
                                                 object_error::parse_failed);
         DebugNames.push_back(wasm::WasmFunctionName{Index, Name});
-        if (Index >= NumImportedFunctions) {
+        if (isDefinedFunctionIndex(Index)) {
           // Override any existing name; the name specified by the "names"
           // section is the Function's canonical name.
-          Functions[Index - NumImportedFunctions].Name = Name;
+          getDefinedFunction(Index).Name = Name;
         }
       }
       break;
     }
     // Ignore local names for now
     case wasm::WASM_NAMES_LOCAL:
     default:
       Ptr += Size;
if (Export.Kind == wasm::WASM_EXTERNAL_FUNCTION ||
         WasmSymbol NewSym(Export.Name, ExportType, ExportSection, Export.Index);
         NewSym.setAltIndex(OldSym.ElementIndex);
         Symbols[SymIndex] = NewSym;
 
         DEBUG(dbgs() << "Replacing existing symbol:  " << NewSym
                      << " sym index:" << SymIndex << "\n");
       }
     }
-    if (Export.Kind == wasm::WASM_EXTERNAL_FUNCTION) {
-      auto &Function = Functions[Export.Index - NumImportedFunctions];
+    if (Export.Kind == wasm::WASM_EXTERNAL_FUNCTION &&
+        isDefinedFunctionIndex(Export.Index)) {
+      auto &Function = getDefinedFunction(Export.Index);
       if (Function.Name.empty()) {
         // Use the export's name to set a name for the Function, but only if one
         // hasn't already been set.
         Function.Name = Export.Name;
       }
     }
   }
 }
while (EntryCount--) {
           return make_error<GenericBinaryError>("COMDAT data index out of range",
                                                 object_error::parse_failed);
         if (!DataSegments[Index].Data.Comdat.empty())
           return make_error<GenericBinaryError>("Data segment in two COMDATs",
                                                 object_error::parse_failed);
         DataSegments[Index].Data.Comdat = Name;
         break;
       case wasm::WASM_COMDAT_FUNCTION:
-        if (Index < NumImportedFunctions || !isValidFunctionIndex(Index))
+        if (!isDefinedFunctionIndex(Index))
           return make_error<GenericBinaryError>("COMDAT function index out of range",
                                                 object_error::parse_failed);
-        Index -= NumImportedFunctions;
-        if (!Functions[Index].Comdat.empty())
+        if (!getDefinedFunction(Index).Comdat.empty())
           return make_error<GenericBinaryError>("Function in two COMDATs",
                                                 object_error::parse_failed);
-        Functions[Index].Comdat = Name;
+        getDefinedFunction(Index).Comdat = Name;
         break;
       }
     }
   }
   return Error::success();
 }
 
 WasmSection* WasmObjectFile::findCustomSectionByName(StringRef Name) {
Error WasmObjectFile::parseExportSection(const uint8_t *Ptr, const uint8_t *End) {
   Exports.reserve(Count);
   for (uint32_t i = 0; i < Count; i++) {
     wasm::WasmExport Ex;
     Ex.Name = readString(Ptr);
     Ex.Kind = readUint8(Ptr);
     Ex.Index = readVaruint32(Ptr);
     switch (Ex.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
-      if (Ex.Index >= FunctionTypes.size() + NumImportedFunctions)
+      if (!isValidFunctionIndex(Ex.Index))
         return make_error<GenericBinaryError>("Invalid function export",
                                               object_error::parse_failed);
       break;
     case wasm::WASM_EXTERNAL_GLOBAL: {
       if (Ex.Index >= Globals.size() + NumImportedGlobals)
         return make_error<GenericBinaryError>("Invalid global export",
                                               object_error::parse_failed);
       break;
return make_error<GenericBinaryError>("Export section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 bool WasmObjectFile::isValidFunctionIndex(uint32_t Index) const {
   return Index < FunctionTypes.size() + NumImportedFunctions;
 }
 
+bool WasmObjectFile::isDefinedFunctionIndex(uint32_t Index) const {
+  return Index >= NumImportedFunctions && isValidFunctionIndex(Index);
+}
+
+wasm::WasmFunction& WasmObjectFile::getDefinedFunction(uint32_t Index) {
+  assert(isDefinedFunctionIndex(Index));
+  return Functions[Index - NumImportedFunctions];
+}
+
 Error WasmObjectFile::parseStartSection(const uint8_t *Ptr, const uint8_t *End) {
   StartFunction = readVaruint32(Ptr);
   if (!isValidFunctionIndex(StartFunction))
     return make_error<GenericBinaryError>("Invalid start function",
                                           object_error::parse_failed);
   return Error::success();
 }