[WebAssembly] clang-format (NFC)

[aheejin]

Summary

This patch runs clang-format on all wasm-only files.

wasm/Driver.cpp

 static void readImportFile(StringRef Filename) {
   if (Optional<MemoryBufferRef> Buf = readFile(Filename))
     for (StringRef Sym : args::getLines(*Buf))
       Config->AllowUndefinedSymbols.insert(Sym);
 }
 
 // Returns slices of MB by parsing MB as an archive file.
 // Each slice consists of a member file in the archive.
-std::vector<MemoryBufferRef> static getArchiveMembers(
-    MemoryBufferRef MB) {
+std::vector<MemoryBufferRef> static getArchiveMembers(MemoryBufferRef MB) {
   std::unique_ptr<Archive> File =
       CHECK(Archive::create(MB),
             MB.getBufferIdentifier() + ": failed to parse archive");
 
   std::vector<MemoryBufferRef> V;
   Error Err = Error::success();
   for (const ErrorOr<Archive::Child> &COrErr : File->children(Err)) {
     Archive::Child C =
         CHECK(COrErr, MB.getBufferIdentifier() +
                           ": could not get the child of the archive");
     MemoryBufferRef MBRef =
         CHECK(C.getMemoryBufferRef(),
               MB.getBufferIdentifier() +
                   ": could not get the buffer for a child of the archive");
     V.push_back(MBRef);
   }
   if (Err)
-    fatal(MB.getBufferIdentifier() + ": Archive::children failed: " +
-          toString(std::move(Err)));
+    fatal(MB.getBufferIdentifier() +
+          ": Archive::children failed: " + toString(std::move(Err)));
 
   // Take ownership of memory buffers created for members of thin archives.
   for (std::unique_ptr<MemoryBuffer> &MB : File->takeThinBuffers())
     make<std::unique_ptr<MemoryBuffer>>(std::move(MB));
 
   return V;
 }
 

wasm/InputChunks.cpp

 using namespace llvm;
 using namespace llvm::wasm;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::wasm;
 
 static StringRef ReloctTypeToString(uint8_t RelocType) {
   switch (RelocType) {
-#define WASM_RELOC(NAME, REL) case REL: return #NAME;
+#define WASM_RELOC(NAME, REL)                                                  \
+  case REL:                                                                    \
+    return #NAME;
 #include "llvm/BinaryFormat/WasmRelocs.def"
 #undef WASM_RELOC
   }
   llvm_unreachable("unknown reloc type");
 }
 
 std::string lld::toString(const InputChunk *C) {
   return (toString(C->File) + ":(" + C->getName() + ")").str();

 
 // Override the default writeTo method so that we can (optionally) write the
 // compressed version of the function.
 void InputFunction::writeTo(uint8_t *Buf) const {
   if (!File || !Config->CompressRelocTargets)
     return InputChunk::writeTo(Buf);
 
   Buf += OutputOffset;
-  uint8_t *Orig = Buf; (void)Orig;
+  uint8_t *Orig = Buf;
+  (void)Orig;
 
   const uint8_t *SecStart = File->CodeSection->Content.data();
   const uint8_t *FuncStart = SecStart + getInputSectionOffset();
   const uint8_t *End = FuncStart + Function->Size;
   uint32_t Count;
   decodeULEB128(FuncStart, &Count);
   FuncStart += Count;
 

wasm/InputFiles.cpp

 
 // Calculate the value we expect to find at the relocation location.
 // This is used as a sanity check before applying a relocation to a given
 // location.  It is useful for catching bugs in the compiler and linker.
 uint32_t ObjFile::calcExpectedValue(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
   case R_WEBASSEMBLY_TABLE_INDEX_I32:
   case R_WEBASSEMBLY_TABLE_INDEX_SLEB: {
-    const WasmSymbol& Sym = WasmObj->syms()[Reloc.Index];
+    const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index];
     return TableEntries[Sym.Info.ElementIndex];
   }
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB: {
-    const WasmSymbol& Sym = WasmObj->syms()[Reloc.Index];
+    const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index];
     if (Sym.isUndefined())
       return 0;
-    const WasmSegment& Segment = WasmObj->dataSegments()[Sym.Info.DataRef.Segment];
+    const WasmSegment &Segment =
+        WasmObj->dataSegments()[Sym.Info.DataRef.Segment];
     return Segment.Data.Offset.Value.Int32 + Sym.Info.DataRef.Offset +
            Reloc.Addend;
   }
   case R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
     if (auto *Sym = dyn_cast<DefinedFunction>(getFunctionSymbol(Reloc.Index))) {
       return Sym->Function->getFunctionInputOffset() +
              Sym->Function->getFunctionCodeOffset() + Reloc.Addend;
     }
     return 0;
   case R_WEBASSEMBLY_SECTION_OFFSET_I32:
     return Reloc.Addend;
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     return Reloc.Index;
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB: {
-    const WasmSymbol& Sym = WasmObj->syms()[Reloc.Index];
+    const WasmSymbol &Sym = WasmObj->syms()[Reloc.Index];
     return Sym.Info.ElementIndex;
   }
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 // Translate from the relocation's index into the final linked output value.

 
 template <class T>
 static void setRelocs(const std::vector<T *> &Chunks,
                       const WasmSection *Section) {
   if (!Section)
     return;
 
   ArrayRef<WasmRelocation> Relocs = Section->Relocations;
-  assert(std::is_sorted(
-      Relocs.begin(), Relocs.end(),
+  assert(std::is_sorted(Relocs.begin(), Relocs.end(),
                         [](const WasmRelocation &R1, const WasmRelocation &R2) {
                           return R1.Offset < R2.Offset;
                         }));
   assert(std::is_sorted(
-      Chunks.begin(), Chunks.end(),
-      [](InputChunk *C1, InputChunk *C2) {
+      Chunks.begin(), Chunks.end(), [](InputChunk *C1, InputChunk *C2) {
         return C1->getInputSectionOffset() < C2->getInputSectionOffset();
       }));
 
   auto RelocsNext = Relocs.begin();
   auto RelocsEnd = Relocs.end();
   auto RelocLess = [](const WasmRelocation &R, uint32_t Val) {
     return R.Offset < Val;
   };
   for (InputChunk *C : Chunks) {
     auto RelocsStart = std::lower_bound(RelocsNext, RelocsEnd,
                                         C->getInputSectionOffset(), RelocLess);
-    RelocsNext = std::lower_bound(RelocsStart, RelocsEnd,
-                                  C->getInputSectionOffset() + C->getInputSize(),
-                                  RelocLess);
+    RelocsNext = std::lower_bound(
+        RelocsStart, RelocsEnd, C->getInputSectionOffset() + C->getInputSize(),
     C->setRelocations(ArrayRef<WasmRelocation>(RelocsStart, RelocsNext));
   }
 }
 
 void ObjFile::parse() {
   // Parse a memory buffer as a wasm file.
   LLVM_DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
   std::unique_ptr<Binary> Bin = CHECK(createBinary(MB), toString(this));
void ObjFile::parse() {
 
   // Populate `Functions`.
   ArrayRef<WasmFunction> Funcs = WasmObj->functions();
   ArrayRef<uint32_t> FuncTypes = WasmObj->functionTypes();
   ArrayRef<WasmSignature> Types = WasmObj->types();
   Functions.reserve(Funcs.size());
 
   for (size_t I = 0, E = Funcs.size(); I != E; ++I)
-    Functions.emplace_back(make<InputFunction>(Types[FuncTypes[I]], &Funcs[I], this));
+    Functions.emplace_back(
+        make<InputFunction>(Types[FuncTypes[I]], &Funcs[I], this));
   setRelocs(Functions, CodeSection);
 
   // Populate `Globals`.
   for (const WasmGlobal &G : WasmObj->globals())
     Globals.emplace_back(make<InputGlobal>(G, this));
 
   // Populate `Symbols` based on the WasmSymbols in the object.
   Symbols.reserve(WasmObj->getNumberOfSymbols());

wasm/OutputSections.h

public:
   void writeRelocations(raw_ostream &OS) const override;
 
 protected:
   ArrayRef<OutputSegment *> Segments;
   std::string DataSectionHeader;
   size_t BodySize = 0;
 };
 
-// Represents a custom section in the output file.  Wasm custom sections are 
+// Represents a custom section in the output file.  Wasm custom sections are
 // used for storing user-defined metadata.  Unlike the core sections types
 // they are identified by their string name.
 // The linker combines custom sections that have the same name by simply
 // concatenating them.
 // Note that some custom sections such as "name" and "linking" are handled
 // separately and are instead synthesized by the linker.
 class CustomSection : public OutputSection {
 public:

wasm/Writer.cpp

 // The default memory layout is as follows, from low to high.
 //
 //  - initialized data (starting at Config->GlobalBase)
 //  - BSS data (not currently implemented in llvm)
 //  - explicit stack (Config->ZStackSize)
 //  - heap start / unallocated
 //
 // The --stack-first option means that stack is placed before any static data.
-// This can be useful since it means that stack overflow traps immediately rather
-// than overwriting global data, but also increases code size since all static
-// data loads and stores requires larger offsets.
+// This can be useful since it means that stack overflow traps immediately
+// rather than overwriting global data, but also increases code size since all
+// static data loads and stores requires larger offsets.
 void Writer::layoutMemory() {
   createOutputSegments();
 
   uint32_t MemoryPtr = 0;
 
   auto PlaceStack = [&]() {
     if (Config->Relocatable)
       return;