lld/wasm/OutputSections.cpp

   1 //===- OutputSections.cpp -------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "OutputSections.h"
  10 #include "InputChunks.h"
  11 #include "InputFiles.h"
  12 #include "OutputSegment.h"
  13 #include "WriterUtils.h"
  14 #include "lld/Common/ErrorHandler.h"
  15 #include "lld/Common/Threads.h"
  16 #include "llvm/ADT/Twine.h"
  17 #include "llvm/Support/LEB128.h"
  18
  19 #define DEBUG_TYPE "lld"
  20
  21 using namespace llvm;
  22 using namespace llvm::wasm;
  23
  24 namespace lld {
  25
  26 // Returns a string, e.g. "FUNCTION(.text)".
  27 std::string toString(const wasm::OutputSection &sec) {
  28   if (!sec.name.empty())
  29     return (sec.getSectionName() + "(" + sec.name + ")").str();
  30   return std::string(sec.getSectionName());
  31 }
  32
  33 namespace wasm {
  34 static StringRef sectionTypeToString(uint32_t sectionType) {
  35   switch (sectionType) {
  36   case WASM_SEC_CUSTOM:
  37     return "CUSTOM";
  38   case WASM_SEC_TYPE:
  39     return "TYPE";
  40   case WASM_SEC_IMPORT:
  41     return "IMPORT";
  42   case WASM_SEC_FUNCTION:
  43     return "FUNCTION";
  44   case WASM_SEC_TABLE:
  45     return "TABLE";
  46   case WASM_SEC_MEMORY:
  47     return "MEMORY";
  48   case WASM_SEC_GLOBAL:
  49     return "GLOBAL";
  50   case WASM_SEC_EVENT:
  51     return "EVENT";
  52   case WASM_SEC_EXPORT:
  53     return "EXPORT";
  54   case WASM_SEC_START:
  55     return "START";
  56   case WASM_SEC_ELEM:
  57     return "ELEM";
  58   case WASM_SEC_CODE:
  59     return "CODE";
  60   case WASM_SEC_DATA:
  61     return "DATA";
  62   case WASM_SEC_DATACOUNT:
  63     return "DATACOUNT";
  64   default:
  65     fatal("invalid section type");
  66   }
  67 }
  68
  69 StringRef OutputSection::getSectionName() const {
  70   return sectionTypeToString(type);
  71 }
  72
  73 void OutputSection::createHeader(size_t bodySize) {
  74   raw_string_ostream os(header);
  75   debugWrite(os.tell(), "section type [" + getSectionName() + "]");
  76   encodeULEB128(type, os);
  77   writeUleb128(os, bodySize, "section size");
  78   os.flush();
  79   log("createHeader: " + toString(*this) + " body=" + Twine(bodySize) +
  80       " total=" + Twine(getSize()));
  81 }
  82
  83 void CodeSection::finalizeContents() {
  84   raw_string_ostream os(codeSectionHeader);
  85   writeUleb128(os, functions.size(), "function count");
  86   os.flush();
  87   bodySize = codeSectionHeader.size();
  88
  89   for (InputFunction *func : functions) {
  90     func->outputOffset = bodySize;
  91     func->calculateSize();
  92     bodySize += func->getSize();
  93   }
  94
  95   createHeader(bodySize);
  96 }
  97
  98 void CodeSection::writeTo(uint8_t *buf) {
  99   log("writing " + toString(*this));
 100   log(" size=" + Twine(getSize()));
 101   log(" headersize=" + Twine(header.size()));
 102   log(" codeheadersize=" + Twine(codeSectionHeader.size()));
 103   buf += offset;
 104
 105   // Write section header
 106   memcpy(buf, header.data(), header.size());
 107   buf += header.size();
 108
 109   // Write code section headers
 110   memcpy(buf, codeSectionHeader.data(), codeSectionHeader.size());
 111
 112   // Write code section bodies
 113   for (const InputChunk *chunk : functions)
 114     chunk->writeTo(buf);
 115 }
 116
 117 uint32_t CodeSection::getNumRelocations() const {
 118   uint32_t count = 0;
 119   for (const InputChunk *func : functions)
 120     count += func->getNumRelocations();
 121   return count;
 122 }
 123
 124 void CodeSection::writeRelocations(raw_ostream &os) const {
 125   for (const InputChunk *c : functions)
 126     c->writeRelocations(os);
 127 }
 128
 129 void DataSection::finalizeContents() {
 130   raw_string_ostream os(dataSectionHeader);
 131   unsigned segmentCount =
 132       std::count_if(segments.begin(), segments.end(),
 133                     [](OutputSegment *segment) { return !segment->isBss; });
 134
 135   writeUleb128(os, segmentCount, "data segment count");
 136   os.flush();
 137   bodySize = dataSectionHeader.size();
 138
 139   assert((!config->isPic || segments.size() <= 1) &&
 140          "Currenly only a single data segment is supported in PIC mode");
 141
 142   for (OutputSegment *segment : segments) {
 143     if (segment->isBss)
 144       continue;
 145     raw_string_ostream os(segment->header);
 146     writeUleb128(os, segment->initFlags, "init flags");
 147     if (segment->initFlags & WASM_SEGMENT_HAS_MEMINDEX)
 148       writeUleb128(os, 0, "memory index");
 149     if ((segment->initFlags & WASM_SEGMENT_IS_PASSIVE) == 0) {
 150       WasmInitExpr initExpr;
 151       if (config->isPic) {
 152         initExpr.Opcode = WASM_OPCODE_GLOBAL_GET;
 153         initExpr.Value.Global = WasmSym::memoryBase->getGlobalIndex();
 154       } else {
 155         initExpr.Opcode = WASM_OPCODE_I32_CONST;
 156         initExpr.Value.Int32 = segment->startVA;
 157       }
 158       writeInitExpr(os, initExpr);
 159     }
 160     writeUleb128(os, segment->size, "segment size");
 161     os.flush();
 162
 163     segment->sectionOffset = bodySize;
 164     bodySize += segment->header.size() + segment->size;
 165     log("Data segment: size=" + Twine(segment->size) + ", startVA=" +
 166         Twine::utohexstr(segment->startVA) + ", name=" + segment->name);
 167
 168     for (InputSegment *inputSeg : segment->inputSegments)
 169       inputSeg->outputOffset = segment->sectionOffset + segment->header.size() +
 170                                inputSeg->outputSegmentOffset;
 171   }
 172
 173   createHeader(bodySize);
 174 }
 175
 176 void DataSection::writeTo(uint8_t *buf) {
 177   log("writing " + toString(*this) + " size=" + Twine(getSize()) +
 178       " body=" + Twine(bodySize));
 179   buf += offset;
 180
 181   // Write section header
 182   memcpy(buf, header.data(), header.size());
 183   buf += header.size();
 184
 185   // Write data section headers
 186   memcpy(buf, dataSectionHeader.data(), dataSectionHeader.size());
 187
 188   for (const OutputSegment *segment : segments) {
 189     if (segment->isBss)
 190       continue;
 191     // Write data segment header
 192     uint8_t *segStart = buf + segment->sectionOffset;
 193     memcpy(segStart, segment->header.data(), segment->header.size());
 194
 195     // Write segment data payload
 196     for (const InputChunk *chunk : segment->inputSegments)
 197       chunk->writeTo(buf);
 198   }
 199 }
 200
 201 uint32_t DataSection::getNumRelocations() const {
 202   uint32_t count = 0;
 203   for (const OutputSegment *seg : segments)
 204     for (const InputChunk *inputSeg : seg->inputSegments)
 205       count += inputSeg->getNumRelocations();
 206   return count;
 207 }
 208
 209 void DataSection::writeRelocations(raw_ostream &os) const {
 210   for (const OutputSegment *seg : segments)
 211     for (const InputChunk *c : seg->inputSegments)
 212       c->writeRelocations(os);
 213 }
 214
 215 bool DataSection::isNeeded() const {
 216   for (const OutputSegment *seg : segments)
 217     if (!seg->isBss)
 218       return true;
 219   return false;
 220 }
 221
 222 void CustomSection::finalizeContents() {
 223   raw_string_ostream os(nameData);
 224   encodeULEB128(name.size(), os);
 225   os << name;
 226   os.flush();
 227
 228   for (InputSection *section : inputSections) {
 229     section->outputOffset = payloadSize;
 230     section->outputSec = this;
 231     payloadSize += section->getSize();
 232   }
 233
 234   createHeader(payloadSize + nameData.size());
 235 }
 236
 237 void CustomSection::writeTo(uint8_t *buf) {
 238   log("writing " + toString(*this) + " size=" + Twine(getSize()) +
 239       " chunks=" + Twine(inputSections.size()));
 240
 241   assert(offset);
 242   buf += offset;
 243
 244   // Write section header
 245   memcpy(buf, header.data(), header.size());
 246   buf += header.size();
 247   memcpy(buf, nameData.data(), nameData.size());
 248   buf += nameData.size();
 249
 250   // Write custom sections payload
 251   for (const InputSection *section : inputSections)
 252     section->writeTo(buf);
 253 }
 254
 255 uint32_t CustomSection::getNumRelocations() const {
 256   uint32_t count = 0;
 257   for (const InputSection *inputSect : inputSections)
 258     count += inputSect->getNumRelocations();
 259   return count;
 260 }
 261
 262 void CustomSection::writeRelocations(raw_ostream &os) const {
 263   for (const InputSection *s : inputSections)
 264     s->writeRelocations(os);
 265 }
 266
 267 } // namespace wasm
 268 } // namespace lld