[WebAssembly] Use ArrayRef over raw pointers

[sbc100]

• clang-format

[ruiu]

wasm/InputChunks.h

148–151

In lld we don't usually define trivial accessors but instead use data members directly.

[sbc100]

wasm/InputChunks.h

148–151

Its only trivial for this subclass.. the method is used on the base class and different subclass have different implementations of data().

[ruiu]

LGTM

data().data() doesn't look very pretty, but that's not your fault...

wasm/InputChunks.h

public:
 
   bool Discarded = false;
   std::vector<OutputRelocation> OutRelocations;
 
 protected:
   InputChunk(const ObjFile *F) : File(F) {}
   virtual ~InputChunk() = default;
   void calcRelocations();
-  virtual const uint8_t *getData() const = 0;
+  virtual ArrayRef<uint8_t> data() const = 0;
   virtual uint32_t getInputSectionOffset() const = 0;
 
   std::vector<WasmRelocation> Relocations;
   int32_t OutputOffset = 0;
   const ObjFile *File;
 };
 
 // Represents a WebAssembly data segment which can be included as part of
public:
 
   const OutputSegment *getOutputSegment() const { return OutputSeg; }
 
   void setOutputSegment(const OutputSegment *Segment, uint32_t Offset) {
     OutputSeg = Segment;
     OutputSegmentOffset = Offset;
   }
 
-  const uint8_t *getData() const override {
-    return Segment.Data.Content.data();
-  }
   uint32_t getSize() const override { return Segment.Data.Content.size(); }
   uint32_t getAlignment() const { return Segment.Data.Alignment; }
   uint32_t startVA() const { return Segment.Data.Offset.Value.Int32; }
   uint32_t endVA() const { return startVA() + getSize(); }
   StringRef getName() const { return Segment.Data.Name; }
   StringRef getComdat() const override { return Segment.Data.Comdat; }
 
   int32_t OutputSegmentOffset = 0;
 
 protected:
+  ArrayRef<uint8_t> data() const override { return Segment.Data.Content; }
   uint32_t getInputSectionOffset() const override {
     return Segment.SectionOffset;
   }
 
   const WasmSegment &Segment;
   const OutputSegment *OutputSeg = nullptr;
 };
 
 // Represents a single wasm function within and input file.  These are
 // combined to create the final output CODE section.
 class InputFunction : public InputChunk {
 public:
   InputFunction(const WasmSignature &S, const WasmFunction *Func,
                 const ObjFile *F)
       : InputChunk(F), Signature(S), WrittenToNameSec(false), Function(Func) {}
 
   uint32_t getSize() const override { return Function->Size; }
-  const uint8_t *getData() const override {
-    return File->CodeSection->Content.data() + getInputSectionOffset();
-  }
   StringRef getComdat() const override { return Function->Comdat; }
   uint32_t getOutputIndex() const { return OutputIndex.getValue(); };
   bool hasOutputIndex() const { return OutputIndex.hasValue(); };
   void setOutputIndex(uint32_t Index);
 
   const WasmSignature &Signature;
 
   unsigned WrittenToNameSec : 1;
 
 protected:
+  ArrayRef<uint8_t> data() const override {
+    return File->CodeSection->Content.slice(getInputSectionOffset(), getSize());
+  }
   uint32_t getInputSectionOffset() const override {
     return Function->CodeSectionOffset;
   }
+
   const WasmFunction *Function;
   llvm::Optional<uint32_t> OutputIndex;
 };
 
 class SyntheticFunction : public InputFunction {
 public:
-  SyntheticFunction(const WasmSignature &S, StringRef Body)
+  SyntheticFunction(const WasmSignature &S, ArrayRef<uint8_t> Body)
       : InputFunction(S, nullptr, nullptr), Body(Body) {}
 
   uint32_t getSize() const override { return Body.size(); }
-  const uint8_t *getData() const override {
-    return reinterpret_cast<const uint8_t *>(Body.data());
-  }
 
 protected:
-  StringRef Body;
+  ArrayRef<uint8_t> data() const override { return Body; }
+
+  ArrayRef<uint8_t> Body;
 };
 
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

wasm/InputChunks.cpp

static void applyRelocations(uint8_t *Buf, ArrayRef<OutputRelocation> Relocs) {
   if (!Relocs.size())
     return;
   DEBUG(dbgs() << "applyRelocations: count=" << Relocs.size() << "\n");
   for (const OutputRelocation &Reloc : Relocs)
     applyRelocation(Buf, Reloc);
 }
 
 void InputChunk::writeTo(uint8_t *SectionStart) const {
-  memcpy(SectionStart + getOutputOffset(), getData(), getSize());
+  memcpy(SectionStart + getOutputOffset(), data().data(), data().size());
   applyRelocations(SectionStart, OutRelocations);
 }
 
 // Populate OutRelocations based on the input relocations and offset within the
 // output section.  Calculates the updated index and offset for each relocation
 // as well as the value to write out in the final binary.
 void InputChunk::calcRelocations() {
   if (Relocations.empty())

wasm/Writer.cpp

static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
     writeU8(OS, OPCODE_END, "END");
   }
 
   // Once we know the size of the body we can create the final function body
   raw_string_ostream OS(CtorFunctionBody);
   writeUleb128(OS, FunctionBody.size(), "function size");
   OS.flush();
   CtorFunctionBody += FunctionBody;
-  CtorFunction =
-      llvm::make_unique<SyntheticFunction>(Signature, CtorFunctionBody);
+  ArrayRef<uint8_t> BodyArray(
+      reinterpret_cast<const uint8_t *>(CtorFunctionBody.data()),
+      CtorFunctionBody.size());
+  CtorFunction = llvm::make_unique<SyntheticFunction>(Signature, BodyArray);
   DefinedFunctions.emplace_back(CtorFunction.get());
 }
 
 // Populate InitFunctions vector with init functions from all input objects.
 // This is then used either when creating the output linking section or to
 // synthesize the "__wasm_call_ctors" function.
 void Writer::calculateInitFunctions() {
   for (ObjFile *File : Symtab->ObjectFiles) {