llvm-project

1
//===- WasmObjectFile.cpp - Wasm object file implementation ---------------===//
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 "llvm/ADT/ArrayRef.h"
10
#include "llvm/ADT/DenseSet.h"
11
#include "llvm/ADT/SmallSet.h"
12
#include "llvm/ADT/StringRef.h"
13
#include "llvm/ADT/StringSet.h"
14
#include "llvm/ADT/StringSwitch.h"
15
#include "llvm/BinaryFormat/Wasm.h"
16
#include "llvm/Object/Binary.h"
17
#include "llvm/Object/Error.h"
18
#include "llvm/Object/ObjectFile.h"
19
#include "llvm/Object/SymbolicFile.h"
20
#include "llvm/Object/Wasm.h"
21
#include "llvm/Support/Endian.h"
22
#include "llvm/Support/Error.h"
23
#include "llvm/Support/ErrorHandling.h"
24
#include "llvm/Support/Format.h"
25
#include "llvm/Support/LEB128.h"
26
#include "llvm/Support/ScopedPrinter.h"
27
#include "llvm/TargetParser/SubtargetFeature.h"
28
#include "llvm/TargetParser/Triple.h"
29
#include <algorithm>
30
#include <cassert>
31
#include <cstdint>
32
#include <cstring>
33
#include <limits>
34

35
#define DEBUG_TYPE "wasm-object"
36

37
using namespace llvm;
38
using namespace object;
39

40
void WasmSymbol::print(raw_ostream &Out) const {
41
  Out << "Name=" << Info.Name
42
      << ", Kind=" << toString(wasm::WasmSymbolType(Info.Kind)) << ", Flags=0x"
43
      << Twine::utohexstr(Info.Flags) << " [";
44
  switch (getBinding()) {
45
    case wasm::WASM_SYMBOL_BINDING_GLOBAL: Out << "global"; break;
46
    case wasm::WASM_SYMBOL_BINDING_LOCAL: Out << "local"; break;
47
    case wasm::WASM_SYMBOL_BINDING_WEAK: Out << "weak"; break;
48
  }
49
  if (isHidden()) {
50
    Out << ", hidden";
51
  } else {
52
    Out << ", default";
53
  }
54
  Out << "]";
55
  if (!isTypeData()) {
56
    Out << ", ElemIndex=" << Info.ElementIndex;
57
  } else if (isDefined()) {
58
    Out << ", Segment=" << Info.DataRef.Segment;
59
    Out << ", Offset=" << Info.DataRef.Offset;
60
    Out << ", Size=" << Info.DataRef.Size;
61
  }
62
}
63

64
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
65
LLVM_DUMP_METHOD void WasmSymbol::dump() const { print(dbgs()); }
66
#endif
67

68
Expected<std::unique_ptr<WasmObjectFile>>
69
ObjectFile::createWasmObjectFile(MemoryBufferRef Buffer) {
70
  Error Err = Error::success();
71
  auto ObjectFile = std::make_unique<WasmObjectFile>(Buffer, Err);
72
  if (Err)
73
    return std::move(Err);
74

75
  return std::move(ObjectFile);
76
}
77

78
#define VARINT7_MAX ((1 << 7) - 1)
79
#define VARINT7_MIN (-(1 << 7))
80
#define VARUINT7_MAX (1 << 7)
81
#define VARUINT1_MAX (1)
82

83
static uint8_t readUint8(WasmObjectFile::ReadContext &Ctx) {
84
  if (Ctx.Ptr == Ctx.End)
85
    report_fatal_error("EOF while reading uint8");
86
  return *Ctx.Ptr++;
87
}
88

89
static uint32_t readUint32(WasmObjectFile::ReadContext &Ctx) {
90
  if (Ctx.Ptr + 4 > Ctx.End)
91
    report_fatal_error("EOF while reading uint32");
92
  uint32_t Result = support::endian::read32le(Ctx.Ptr);
93
  Ctx.Ptr += 4;
94
  return Result;
95
}
96

97
static int32_t readFloat32(WasmObjectFile::ReadContext &Ctx) {
98
  if (Ctx.Ptr + 4 > Ctx.End)
99
    report_fatal_error("EOF while reading float64");
100
  int32_t Result = 0;
101
  memcpy(&Result, Ctx.Ptr, sizeof(Result));
102
  Ctx.Ptr += sizeof(Result);
103
  return Result;
104
}
105

106
static int64_t readFloat64(WasmObjectFile::ReadContext &Ctx) {
107
  if (Ctx.Ptr + 8 > Ctx.End)
108
    report_fatal_error("EOF while reading float64");
109
  int64_t Result = 0;
110
  memcpy(&Result, Ctx.Ptr, sizeof(Result));
111
  Ctx.Ptr += sizeof(Result);
112
  return Result;
113
}
114

115
static uint64_t readULEB128(WasmObjectFile::ReadContext &Ctx) {
116
  unsigned Count;
117
  const char *Error = nullptr;
118
  uint64_t Result = decodeULEB128(Ctx.Ptr, &Count, Ctx.End, &Error);
119
  if (Error)
120
    report_fatal_error(Error);
121
  Ctx.Ptr += Count;
122
  return Result;
123
}
124

125
static StringRef readString(WasmObjectFile::ReadContext &Ctx) {
126
  uint32_t StringLen = readULEB128(Ctx);
127
  if (Ctx.Ptr + StringLen > Ctx.End)
128
    report_fatal_error("EOF while reading string");
129
  StringRef Return =
130
      StringRef(reinterpret_cast<const char *>(Ctx.Ptr), StringLen);
131
  Ctx.Ptr += StringLen;
132
  return Return;
133
}
134

135
static int64_t readLEB128(WasmObjectFile::ReadContext &Ctx) {
136
  unsigned Count;
137
  const char *Error = nullptr;
138
  uint64_t Result = decodeSLEB128(Ctx.Ptr, &Count, Ctx.End, &Error);
139
  if (Error)
140
    report_fatal_error(Error);
141
  Ctx.Ptr += Count;
142
  return Result;
143
}
144

145
static uint8_t readVaruint1(WasmObjectFile::ReadContext &Ctx) {
146
  int64_t Result = readLEB128(Ctx);
147
  if (Result > VARUINT1_MAX || Result < 0)
148
    report_fatal_error("LEB is outside Varuint1 range");
149
  return Result;
150
}
151

152
static int32_t readVarint32(WasmObjectFile::ReadContext &Ctx) {
153
  int64_t Result = readLEB128(Ctx);
154
  if (Result > INT32_MAX || Result < INT32_MIN)
155
    report_fatal_error("LEB is outside Varint32 range");
156
  return Result;
157
}
158

159
static uint32_t readVaruint32(WasmObjectFile::ReadContext &Ctx) {
160
  uint64_t Result = readULEB128(Ctx);
161
  if (Result > UINT32_MAX)
162
    report_fatal_error("LEB is outside Varuint32 range");
163
  return Result;
164
}
165

166
static int64_t readVarint64(WasmObjectFile::ReadContext &Ctx) {
167
  return readLEB128(Ctx);
168
}
169

170
static uint64_t readVaruint64(WasmObjectFile::ReadContext &Ctx) {
171
  return readULEB128(Ctx);
172
}
173

174
static uint8_t readOpcode(WasmObjectFile::ReadContext &Ctx) {
175
  return readUint8(Ctx);
176
}
177

178
static wasm::ValType parseValType(WasmObjectFile::ReadContext &Ctx,
179
                                  uint32_t Code) {
180
  // only directly encoded FUNCREF/EXTERNREF/EXNREF are supported
181
  // (not ref null func, ref null extern, or ref null exn)
182
  switch (Code) {
183
  case wasm::WASM_TYPE_I32:
184
  case wasm::WASM_TYPE_I64:
185
  case wasm::WASM_TYPE_F32:
186
  case wasm::WASM_TYPE_F64:
187
  case wasm::WASM_TYPE_V128:
188
  case wasm::WASM_TYPE_FUNCREF:
189
  case wasm::WASM_TYPE_EXTERNREF:
190
  case wasm::WASM_TYPE_EXNREF:
191
    return wasm::ValType(Code);
192
  }
193
  if (Code == wasm::WASM_TYPE_NULLABLE || Code == wasm::WASM_TYPE_NONNULLABLE) {
194
    /* Discard HeapType */ readVarint64(Ctx);
195
  }
196
  return wasm::ValType(wasm::ValType::OTHERREF);
197
}
198

199
static Error readInitExpr(wasm::WasmInitExpr &Expr,
200
                          WasmObjectFile::ReadContext &Ctx) {
201
  auto Start = Ctx.Ptr;
202

203
  Expr.Extended = false;
204
  Expr.Inst.Opcode = readOpcode(Ctx);
205
  switch (Expr.Inst.Opcode) {
206
  case wasm::WASM_OPCODE_I32_CONST:
207
    Expr.Inst.Value.Int32 = readVarint32(Ctx);
208
    break;
209
  case wasm::WASM_OPCODE_I64_CONST:
210
    Expr.Inst.Value.Int64 = readVarint64(Ctx);
211
    break;
212
  case wasm::WASM_OPCODE_F32_CONST:
213
    Expr.Inst.Value.Float32 = readFloat32(Ctx);
214
    break;
215
  case wasm::WASM_OPCODE_F64_CONST:
216
    Expr.Inst.Value.Float64 = readFloat64(Ctx);
217
    break;
218
  case wasm::WASM_OPCODE_GLOBAL_GET:
219
    Expr.Inst.Value.Global = readULEB128(Ctx);
220
    break;
221
  case wasm::WASM_OPCODE_REF_NULL: {
222
    /* Discard type */ parseValType(Ctx, readVaruint32(Ctx));
223
    break;
224
  }
225
  default:
226
    Expr.Extended = true;
227
  }
228

229
  if (!Expr.Extended) {
230
    uint8_t EndOpcode = readOpcode(Ctx);
231
    if (EndOpcode != wasm::WASM_OPCODE_END)
232
      Expr.Extended = true;
233
  }
234

235
  if (Expr.Extended) {
236
    Ctx.Ptr = Start;
237
    while (true) {
238
      uint8_t Opcode = readOpcode(Ctx);
239
      switch (Opcode) {
240
      case wasm::WASM_OPCODE_I32_CONST:
241
      case wasm::WASM_OPCODE_GLOBAL_GET:
242
      case wasm::WASM_OPCODE_REF_NULL:
243
      case wasm::WASM_OPCODE_REF_FUNC:
244
      case wasm::WASM_OPCODE_I64_CONST:
245
        readULEB128(Ctx);
246
        break;
247
      case wasm::WASM_OPCODE_F32_CONST:
248
        readFloat32(Ctx);
249
        break;
250
      case wasm::WASM_OPCODE_F64_CONST:
251
        readFloat64(Ctx);
252
        break;
253
      case wasm::WASM_OPCODE_I32_ADD:
254
      case wasm::WASM_OPCODE_I32_SUB:
255
      case wasm::WASM_OPCODE_I32_MUL:
256
      case wasm::WASM_OPCODE_I64_ADD:
257
      case wasm::WASM_OPCODE_I64_SUB:
258
      case wasm::WASM_OPCODE_I64_MUL:
259
        break;
260
      case wasm::WASM_OPCODE_GC_PREFIX:
261
        break;
262
      // The GC opcodes are in a separate (prefixed space). This flat switch
263
      // structure works as long as there is no overlap between the GC and
264
      // general opcodes used in init exprs.
265
      case wasm::WASM_OPCODE_STRUCT_NEW:
266
      case wasm::WASM_OPCODE_STRUCT_NEW_DEFAULT:
267
      case wasm::WASM_OPCODE_ARRAY_NEW:
268
      case wasm::WASM_OPCODE_ARRAY_NEW_DEFAULT:
269
        readULEB128(Ctx); // heap type index
270
        break;
271
      case wasm::WASM_OPCODE_ARRAY_NEW_FIXED:
272
        readULEB128(Ctx); // heap type index
273
        readULEB128(Ctx); // array size
274
        break;
275
      case wasm::WASM_OPCODE_REF_I31:
276
        break;
277
      case wasm::WASM_OPCODE_END:
278
        Expr.Body = ArrayRef<uint8_t>(Start, Ctx.Ptr - Start);
279
        return Error::success();
280
      default:
281
        return make_error<GenericBinaryError>(
282
            Twine("invalid opcode in init_expr: ") + Twine(unsigned(Opcode)),
283
            object_error::parse_failed);
284
      }
285
    }
286
  }
287

288
  return Error::success();
289
}
290

291
static wasm::WasmLimits readLimits(WasmObjectFile::ReadContext &Ctx) {
292
  wasm::WasmLimits Result;
293
  Result.Flags = readVaruint32(Ctx);
294
  Result.Minimum = readVaruint64(Ctx);
295
  if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
296
    Result.Maximum = readVaruint64(Ctx);
297
  return Result;
298
}
299

300
static wasm::WasmTableType readTableType(WasmObjectFile::ReadContext &Ctx) {
301
  wasm::WasmTableType TableType;
302
  auto ElemType = parseValType(Ctx, readVaruint32(Ctx));
303
  TableType.ElemType = ElemType;
304
  TableType.Limits = readLimits(Ctx);
305
  return TableType;
306
}
307

308
static Error readSection(WasmSection &Section, WasmObjectFile::ReadContext &Ctx,
309
                         WasmSectionOrderChecker &Checker) {
310
  Section.Type = readUint8(Ctx);
311
  LLVM_DEBUG(dbgs() << "readSection type=" << Section.Type << "\n");
312
  // When reading the section's size, store the size of the LEB used to encode
313
  // it. This allows objcopy/strip to reproduce the binary identically.
314
  const uint8_t *PreSizePtr = Ctx.Ptr;
315
  uint32_t Size = readVaruint32(Ctx);
316
  Section.HeaderSecSizeEncodingLen = Ctx.Ptr - PreSizePtr;
317
  Section.Offset = Ctx.Ptr - Ctx.Start;
318
  if (Size == 0)
319
    return make_error<StringError>("zero length section",
320
                                   object_error::parse_failed);
321
  if (Ctx.Ptr + Size > Ctx.End)
322
    return make_error<StringError>("section too large",
323
                                   object_error::parse_failed);
324
  if (Section.Type == wasm::WASM_SEC_CUSTOM) {
325
    WasmObjectFile::ReadContext SectionCtx;
326
    SectionCtx.Start = Ctx.Ptr;
327
    SectionCtx.Ptr = Ctx.Ptr;
328
    SectionCtx.End = Ctx.Ptr + Size;
329

330
    Section.Name = readString(SectionCtx);
331

332
    uint32_t SectionNameSize = SectionCtx.Ptr - SectionCtx.Start;
333
    Ctx.Ptr += SectionNameSize;
334
    Size -= SectionNameSize;
335
  }
336

337
  if (!Checker.isValidSectionOrder(Section.Type, Section.Name)) {
338
    return make_error<StringError>("out of order section type: " +
339
                                       llvm::to_string(Section.Type),
340
                                   object_error::parse_failed);
341
  }
342

343
  Section.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
344
  Ctx.Ptr += Size;
345
  return Error::success();
346
}
347

348
WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
349
    : ObjectFile(Binary::ID_Wasm, Buffer) {
350
  ErrorAsOutParameter ErrAsOutParam(&Err);
351
  Header.Magic = getData().substr(0, 4);
352
  if (Header.Magic != StringRef("\0asm", 4)) {
353
    Err = make_error<StringError>("invalid magic number",
354
                                  object_error::parse_failed);
355
    return;
356
  }
357

358
  ReadContext Ctx;
359
  Ctx.Start = getData().bytes_begin();
360
  Ctx.Ptr = Ctx.Start + 4;
361
  Ctx.End = Ctx.Start + getData().size();
362

363
  if (Ctx.Ptr + 4 > Ctx.End) {
364
    Err = make_error<StringError>("missing version number",
365
                                  object_error::parse_failed);
366
    return;
367
  }
368

369
  Header.Version = readUint32(Ctx);
370
  if (Header.Version != wasm::WasmVersion) {
371
    Err = make_error<StringError>("invalid version number: " +
372
                                      Twine(Header.Version),
373
                                  object_error::parse_failed);
374
    return;
375
  }
376

377
  WasmSectionOrderChecker Checker;
378
  while (Ctx.Ptr < Ctx.End) {
379
    WasmSection Sec;
380
    if ((Err = readSection(Sec, Ctx, Checker)))
381
      return;
382
    if ((Err = parseSection(Sec)))
383
      return;
384

385
    Sections.push_back(Sec);
386
  }
387
}
388

389
Error WasmObjectFile::parseSection(WasmSection &Sec) {
390
  ReadContext Ctx;
391
  Ctx.Start = Sec.Content.data();
392
  Ctx.End = Ctx.Start + Sec.Content.size();
393
  Ctx.Ptr = Ctx.Start;
394
  switch (Sec.Type) {
395
  case wasm::WASM_SEC_CUSTOM:
396
    return parseCustomSection(Sec, Ctx);
397
  case wasm::WASM_SEC_TYPE:
398
    return parseTypeSection(Ctx);
399
  case wasm::WASM_SEC_IMPORT:
400
    return parseImportSection(Ctx);
401
  case wasm::WASM_SEC_FUNCTION:
402
    return parseFunctionSection(Ctx);
403
  case wasm::WASM_SEC_TABLE:
404
    return parseTableSection(Ctx);
405
  case wasm::WASM_SEC_MEMORY:
406
    return parseMemorySection(Ctx);
407
  case wasm::WASM_SEC_TAG:
408
    return parseTagSection(Ctx);
409
  case wasm::WASM_SEC_GLOBAL:
410
    return parseGlobalSection(Ctx);
411
  case wasm::WASM_SEC_EXPORT:
412
    return parseExportSection(Ctx);
413
  case wasm::WASM_SEC_START:
414
    return parseStartSection(Ctx);
415
  case wasm::WASM_SEC_ELEM:
416
    return parseElemSection(Ctx);
417
  case wasm::WASM_SEC_CODE:
418
    return parseCodeSection(Ctx);
419
  case wasm::WASM_SEC_DATA:
420
    return parseDataSection(Ctx);
421
  case wasm::WASM_SEC_DATACOUNT:
422
    return parseDataCountSection(Ctx);
423
  default:
424
    return make_error<GenericBinaryError>(
425
        "invalid section type: " + Twine(Sec.Type), object_error::parse_failed);
426
  }
427
}
428

429
Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
430
  // Legacy "dylink" section support.
431
  // See parseDylink0Section for the current "dylink.0" section parsing.
432
  HasDylinkSection = true;
433
  DylinkInfo.MemorySize = readVaruint32(Ctx);
434
  DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
435
  DylinkInfo.TableSize = readVaruint32(Ctx);
436
  DylinkInfo.TableAlignment = readVaruint32(Ctx);
437
  uint32_t Count = readVaruint32(Ctx);
438
  while (Count--) {
439
    DylinkInfo.Needed.push_back(readString(Ctx));
440
  }
441

442
  if (Ctx.Ptr != Ctx.End)
443
    return make_error<GenericBinaryError>("dylink section ended prematurely",
444
                                          object_error::parse_failed);
445
  return Error::success();
446
}
447

448
Error WasmObjectFile::parseDylink0Section(ReadContext &Ctx) {
449
  // See
450
  // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
451
  HasDylinkSection = true;
452

453
  const uint8_t *OrigEnd = Ctx.End;
454
  while (Ctx.Ptr < OrigEnd) {
455
    Ctx.End = OrigEnd;
456
    uint8_t Type = readUint8(Ctx);
457
    uint32_t Size = readVaruint32(Ctx);
458
    LLVM_DEBUG(dbgs() << "readSubsection type=" << int(Type) << " size=" << Size
459
                      << "\n");
460
    Ctx.End = Ctx.Ptr + Size;
461
    uint32_t Count;
462
    switch (Type) {
463
    case wasm::WASM_DYLINK_MEM_INFO:
464
      DylinkInfo.MemorySize = readVaruint32(Ctx);
465
      DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
466
      DylinkInfo.TableSize = readVaruint32(Ctx);
467
      DylinkInfo.TableAlignment = readVaruint32(Ctx);
468
      break;
469
    case wasm::WASM_DYLINK_NEEDED:
470
      Count = readVaruint32(Ctx);
471
      while (Count--) {
472
        DylinkInfo.Needed.push_back(readString(Ctx));
473
      }
474
      break;
475
    case wasm::WASM_DYLINK_EXPORT_INFO: {
476
      uint32_t Count = readVaruint32(Ctx);
477
      while (Count--) {
478
        DylinkInfo.ExportInfo.push_back({readString(Ctx), readVaruint32(Ctx)});
479
      }
480
      break;
481
    }
482
    case wasm::WASM_DYLINK_IMPORT_INFO: {
483
      uint32_t Count = readVaruint32(Ctx);
484
      while (Count--) {
485
        DylinkInfo.ImportInfo.push_back(
486
            {readString(Ctx), readString(Ctx), readVaruint32(Ctx)});
487
      }
488
      break;
489
    }
490
    default:
491
      LLVM_DEBUG(dbgs() << "unknown dylink.0 sub-section: " << Type << "\n");
492
      Ctx.Ptr += Size;
493
      break;
494
    }
495
    if (Ctx.Ptr != Ctx.End) {
496
      return make_error<GenericBinaryError>(
497
          "dylink.0 sub-section ended prematurely", object_error::parse_failed);
498
    }
499
  }
500

501
  if (Ctx.Ptr != Ctx.End)
502
    return make_error<GenericBinaryError>("dylink.0 section ended prematurely",
503
                                          object_error::parse_failed);
504
  return Error::success();
505
}
506

507
Error WasmObjectFile::parseNameSection(ReadContext &Ctx) {
508
  llvm::DenseSet<uint64_t> SeenFunctions;
509
  llvm::DenseSet<uint64_t> SeenGlobals;
510
  llvm::DenseSet<uint64_t> SeenSegments;
511

512
  // If there is symbol info from the export section, this info will supersede
513
  // it, but not info from a linking section
514
  if (!HasLinkingSection) {
515
    Symbols.clear();
516
  }
517

518
  while (Ctx.Ptr < Ctx.End) {
519
    uint8_t Type = readUint8(Ctx);
520
    uint32_t Size = readVaruint32(Ctx);
521
    const uint8_t *SubSectionEnd = Ctx.Ptr + Size;
522

523
    switch (Type) {
524
    case wasm::WASM_NAMES_FUNCTION:
525
    case wasm::WASM_NAMES_GLOBAL:
526
    case wasm::WASM_NAMES_DATA_SEGMENT: {
527
      uint32_t Count = readVaruint32(Ctx);
528
      while (Count--) {
529
        uint32_t Index = readVaruint32(Ctx);
530
        StringRef Name = readString(Ctx);
531
        wasm::NameType nameType = wasm::NameType::FUNCTION;
532
        wasm::WasmSymbolInfo Info{Name,
533
                                  /*Kind */ wasm::WASM_SYMBOL_TYPE_FUNCTION,
534
                                  /* Flags */ 0,
535
                                  /* ImportModule */ std::nullopt,
536
                                  /* ImportName */ std::nullopt,
537
                                  /* ExportName */ std::nullopt,
538
                                  {/* ElementIndex */ Index}};
539
        const wasm::WasmSignature *Signature = nullptr;
540
        const wasm::WasmGlobalType *GlobalType = nullptr;
541
        const wasm::WasmTableType *TableType = nullptr;
542
        if (Type == wasm::WASM_NAMES_FUNCTION) {
543
          if (!SeenFunctions.insert(Index).second)
544
            return make_error<GenericBinaryError>(
545
                "function named more than once", object_error::parse_failed);
546
          if (!isValidFunctionIndex(Index) || Name.empty())
547
            return make_error<GenericBinaryError>("invalid function name entry",
548
                                                  object_error::parse_failed);
549

550
          if (isDefinedFunctionIndex(Index)) {
551
            wasm::WasmFunction &F = getDefinedFunction(Index);
552
            F.DebugName = Name;
553
            Signature = &Signatures[F.SigIndex];
554
            if (F.ExportName) {
555
              Info.ExportName = F.ExportName;
556
              Info.Flags |= wasm::WASM_SYMBOL_BINDING_GLOBAL;
557
            } else {
558
              Info.Flags |= wasm::WASM_SYMBOL_BINDING_LOCAL;
559
            }
560
          } else {
561
            Info.Flags |= wasm::WASM_SYMBOL_UNDEFINED;
562
          }
563
        } else if (Type == wasm::WASM_NAMES_GLOBAL) {
564
          if (!SeenGlobals.insert(Index).second)
565
            return make_error<GenericBinaryError>("global named more than once",
566
                                                  object_error::parse_failed);
567
          if (!isValidGlobalIndex(Index) || Name.empty())
568
            return make_error<GenericBinaryError>("invalid global name entry",
569
                                                  object_error::parse_failed);
570
          nameType = wasm::NameType::GLOBAL;
571
          Info.Kind = wasm::WASM_SYMBOL_TYPE_GLOBAL;
572
          if (isDefinedGlobalIndex(Index)) {
573
            GlobalType = &getDefinedGlobal(Index).Type;
574
          } else {
575
            Info.Flags |= wasm::WASM_SYMBOL_UNDEFINED;
576
          }
577
        } else {
578
          if (!SeenSegments.insert(Index).second)
579
            return make_error<GenericBinaryError>(
580
                "segment named more than once", object_error::parse_failed);
581
          if (Index > DataSegments.size())
582
            return make_error<GenericBinaryError>("invalid data segment name entry",
583
                                                  object_error::parse_failed);
584
          nameType = wasm::NameType::DATA_SEGMENT;
585
          Info.Kind = wasm::WASM_SYMBOL_TYPE_DATA;
586
          Info.Flags |= wasm::WASM_SYMBOL_BINDING_LOCAL;
587
          assert(Index < DataSegments.size());
588
          Info.DataRef = wasm::WasmDataReference{
589
              Index, 0, DataSegments[Index].Data.Content.size()};
590
        }
591
        DebugNames.push_back(wasm::WasmDebugName{nameType, Index, Name});
592
        if (!HasLinkingSection)
593
          Symbols.emplace_back(Info, GlobalType, TableType, Signature);
594
      }
595
      break;
596
    }
597
    // Ignore local names for now
598
    case wasm::WASM_NAMES_LOCAL:
599
    default:
600
      Ctx.Ptr += Size;
601
      break;
602
    }
603
    if (Ctx.Ptr != SubSectionEnd)
604
      return make_error<GenericBinaryError>(
605
          "name sub-section ended prematurely", object_error::parse_failed);
606
  }
607

608
  if (Ctx.Ptr != Ctx.End)
609
    return make_error<GenericBinaryError>("name section ended prematurely",
610
                                          object_error::parse_failed);
611
  return Error::success();
612
}
613

614
Error WasmObjectFile::parseLinkingSection(ReadContext &Ctx) {
615
  HasLinkingSection = true;
616

617
  LinkingData.Version = readVaruint32(Ctx);
618
  if (LinkingData.Version != wasm::WasmMetadataVersion) {
619
    return make_error<GenericBinaryError>(
620
        "unexpected metadata version: " + Twine(LinkingData.Version) +
621
            " (Expected: " + Twine(wasm::WasmMetadataVersion) + ")",
622
        object_error::parse_failed);
623
  }
624

625
  const uint8_t *OrigEnd = Ctx.End;
626
  while (Ctx.Ptr < OrigEnd) {
627
    Ctx.End = OrigEnd;
628
    uint8_t Type = readUint8(Ctx);
629
    uint32_t Size = readVaruint32(Ctx);
630
    LLVM_DEBUG(dbgs() << "readSubsection type=" << int(Type) << " size=" << Size
631
                      << "\n");
632
    Ctx.End = Ctx.Ptr + Size;
633
    switch (Type) {
634
    case wasm::WASM_SYMBOL_TABLE:
635
      if (Error Err = parseLinkingSectionSymtab(Ctx))
636
        return Err;
637
      break;
638
    case wasm::WASM_SEGMENT_INFO: {
639
      uint32_t Count = readVaruint32(Ctx);
640
      if (Count > DataSegments.size())
641
        return make_error<GenericBinaryError>("too many segment names",
642
                                              object_error::parse_failed);
643
      for (uint32_t I = 0; I < Count; I++) {
644
        DataSegments[I].Data.Name = readString(Ctx);
645
        DataSegments[I].Data.Alignment = readVaruint32(Ctx);
646
        DataSegments[I].Data.LinkingFlags = readVaruint32(Ctx);
647
      }
648
      break;
649
    }
650
    case wasm::WASM_INIT_FUNCS: {
651
      uint32_t Count = readVaruint32(Ctx);
652
      LinkingData.InitFunctions.reserve(Count);
653
      for (uint32_t I = 0; I < Count; I++) {
654
        wasm::WasmInitFunc Init;
655
        Init.Priority = readVaruint32(Ctx);
656
        Init.Symbol = readVaruint32(Ctx);
657
        if (!isValidFunctionSymbol(Init.Symbol))
658
          return make_error<GenericBinaryError>("invalid function symbol: " +
659
                                                    Twine(Init.Symbol),
660
                                                object_error::parse_failed);
661
        LinkingData.InitFunctions.emplace_back(Init);
662
      }
663
      break;
664
    }
665
    case wasm::WASM_COMDAT_INFO:
666
      if (Error Err = parseLinkingSectionComdat(Ctx))
667
        return Err;
668
      break;
669
    default:
670
      Ctx.Ptr += Size;
671
      break;
672
    }
673
    if (Ctx.Ptr != Ctx.End)
674
      return make_error<GenericBinaryError>(
675
          "linking sub-section ended prematurely", object_error::parse_failed);
676
  }
677
  if (Ctx.Ptr != OrigEnd)
678
    return make_error<GenericBinaryError>("linking section ended prematurely",
679
                                          object_error::parse_failed);
680
  return Error::success();
681
}
682

683
Error WasmObjectFile::parseLinkingSectionSymtab(ReadContext &Ctx) {
684
  uint32_t Count = readVaruint32(Ctx);
685
  // Clear out any symbol information that was derived from the exports
686
  // section.
687
  Symbols.clear();
688
  Symbols.reserve(Count);
689
  StringSet<> SymbolNames;
690

691
  std::vector<wasm::WasmImport *> ImportedGlobals;
692
  std::vector<wasm::WasmImport *> ImportedFunctions;
693
  std::vector<wasm::WasmImport *> ImportedTags;
694
  std::vector<wasm::WasmImport *> ImportedTables;
695
  ImportedGlobals.reserve(Imports.size());
696
  ImportedFunctions.reserve(Imports.size());
697
  ImportedTags.reserve(Imports.size());
698
  ImportedTables.reserve(Imports.size());
699
  for (auto &I : Imports) {
700
    if (I.Kind == wasm::WASM_EXTERNAL_FUNCTION)
701
      ImportedFunctions.emplace_back(&I);
702
    else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
703
      ImportedGlobals.emplace_back(&I);
704
    else if (I.Kind == wasm::WASM_EXTERNAL_TAG)
705
      ImportedTags.emplace_back(&I);
706
    else if (I.Kind == wasm::WASM_EXTERNAL_TABLE)
707
      ImportedTables.emplace_back(&I);
708
  }
709

710
  while (Count--) {
711
    wasm::WasmSymbolInfo Info;
712
    const wasm::WasmSignature *Signature = nullptr;
713
    const wasm::WasmGlobalType *GlobalType = nullptr;
714
    const wasm::WasmTableType *TableType = nullptr;
715

716
    Info.Kind = readUint8(Ctx);
717
    Info.Flags = readVaruint32(Ctx);
718
    bool IsDefined = (Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0;
719

720
    switch (Info.Kind) {
721
    case wasm::WASM_SYMBOL_TYPE_FUNCTION:
722
      Info.ElementIndex = readVaruint32(Ctx);
723
      if (!isValidFunctionIndex(Info.ElementIndex) ||
724
          IsDefined != isDefinedFunctionIndex(Info.ElementIndex))
725
        return make_error<GenericBinaryError>("invalid function symbol index",
726
                                              object_error::parse_failed);
727
      if (IsDefined) {
728
        Info.Name = readString(Ctx);
729
        unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
730
        wasm::WasmFunction &Function = Functions[FuncIndex];
731
        Signature = &Signatures[Function.SigIndex];
732
        if (Function.SymbolName.empty())
733
          Function.SymbolName = Info.Name;
734
      } else {
735
        wasm::WasmImport &Import = *ImportedFunctions[Info.ElementIndex];
736
        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
737
          Info.Name = readString(Ctx);
738
          Info.ImportName = Import.Field;
739
        } else {
740
          Info.Name = Import.Field;
741
        }
742
        Signature = &Signatures[Import.SigIndex];
743
        Info.ImportModule = Import.Module;
744
      }
745
      break;
746

747
    case wasm::WASM_SYMBOL_TYPE_GLOBAL:
748
      Info.ElementIndex = readVaruint32(Ctx);
749
      if (!isValidGlobalIndex(Info.ElementIndex) ||
750
          IsDefined != isDefinedGlobalIndex(Info.ElementIndex))
751
        return make_error<GenericBinaryError>("invalid global symbol index",
752
                                              object_error::parse_failed);
753
      if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
754
                            wasm::WASM_SYMBOL_BINDING_WEAK)
755
        return make_error<GenericBinaryError>("undefined weak global symbol",
756
                                              object_error::parse_failed);
757
      if (IsDefined) {
758
        Info.Name = readString(Ctx);
759
        unsigned GlobalIndex = Info.ElementIndex - NumImportedGlobals;
760
        wasm::WasmGlobal &Global = Globals[GlobalIndex];
761
        GlobalType = &Global.Type;
762
        if (Global.SymbolName.empty())
763
          Global.SymbolName = Info.Name;
764
      } else {
765
        wasm::WasmImport &Import = *ImportedGlobals[Info.ElementIndex];
766
        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
767
          Info.Name = readString(Ctx);
768
          Info.ImportName = Import.Field;
769
        } else {
770
          Info.Name = Import.Field;
771
        }
772
        GlobalType = &Import.Global;
773
        Info.ImportModule = Import.Module;
774
      }
775
      break;
776

777
    case wasm::WASM_SYMBOL_TYPE_TABLE:
778
      Info.ElementIndex = readVaruint32(Ctx);
779
      if (!isValidTableNumber(Info.ElementIndex) ||
780
          IsDefined != isDefinedTableNumber(Info.ElementIndex))
781
        return make_error<GenericBinaryError>("invalid table symbol index",
782
                                              object_error::parse_failed);
783
      if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
784
                            wasm::WASM_SYMBOL_BINDING_WEAK)
785
        return make_error<GenericBinaryError>("undefined weak table symbol",
786
                                              object_error::parse_failed);
787
      if (IsDefined) {
788
        Info.Name = readString(Ctx);
789
        unsigned TableNumber = Info.ElementIndex - NumImportedTables;
790
        wasm::WasmTable &Table = Tables[TableNumber];
791
        TableType = &Table.Type;
792
        if (Table.SymbolName.empty())
793
          Table.SymbolName = Info.Name;
794
      } else {
795
        wasm::WasmImport &Import = *ImportedTables[Info.ElementIndex];
796
        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
797
          Info.Name = readString(Ctx);
798
          Info.ImportName = Import.Field;
799
        } else {
800
          Info.Name = Import.Field;
801
        }
802
        TableType = &Import.Table;
803
        Info.ImportModule = Import.Module;
804
      }
805
      break;
806

807
    case wasm::WASM_SYMBOL_TYPE_DATA:
808
      Info.Name = readString(Ctx);
809
      if (IsDefined) {
810
        auto Index = readVaruint32(Ctx);
811
        auto Offset = readVaruint64(Ctx);
812
        auto Size = readVaruint64(Ctx);
813
        if (!(Info.Flags & wasm::WASM_SYMBOL_ABSOLUTE)) {
814
          if (static_cast<size_t>(Index) >= DataSegments.size())
815
            return make_error<GenericBinaryError>(
816
                "invalid data segment index: " + Twine(Index),
817
                object_error::parse_failed);
818
          size_t SegmentSize = DataSegments[Index].Data.Content.size();
819
          if (Offset > SegmentSize)
820
            return make_error<GenericBinaryError>(
821
                "invalid data symbol offset: `" + Info.Name +
822
                    "` (offset: " + Twine(Offset) +
823
                    " segment size: " + Twine(SegmentSize) + ")",
824
                object_error::parse_failed);
825
        }
826
        Info.DataRef = wasm::WasmDataReference{Index, Offset, Size};
827
      }
828
      break;
829

830
    case wasm::WASM_SYMBOL_TYPE_SECTION: {
831
      if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
832
          wasm::WASM_SYMBOL_BINDING_LOCAL)
833
        return make_error<GenericBinaryError>(
834
            "section symbols must have local binding",
835
            object_error::parse_failed);
836
      Info.ElementIndex = readVaruint32(Ctx);
837
      // Use somewhat unique section name as symbol name.
838
      StringRef SectionName = Sections[Info.ElementIndex].Name;
839
      Info.Name = SectionName;
840
      break;
841
    }
842

843
    case wasm::WASM_SYMBOL_TYPE_TAG: {
844
      Info.ElementIndex = readVaruint32(Ctx);
845
      if (!isValidTagIndex(Info.ElementIndex) ||
846
          IsDefined != isDefinedTagIndex(Info.ElementIndex))
847
        return make_error<GenericBinaryError>("invalid tag symbol index",
848
                                              object_error::parse_failed);
849
      if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
850
                            wasm::WASM_SYMBOL_BINDING_WEAK)
851
        return make_error<GenericBinaryError>("undefined weak global symbol",
852
                                              object_error::parse_failed);
853
      if (IsDefined) {
854
        Info.Name = readString(Ctx);
855
        unsigned TagIndex = Info.ElementIndex - NumImportedTags;
856
        wasm::WasmTag &Tag = Tags[TagIndex];
857
        Signature = &Signatures[Tag.SigIndex];
858
        if (Tag.SymbolName.empty())
859
          Tag.SymbolName = Info.Name;
860

861
      } else {
862
        wasm::WasmImport &Import = *ImportedTags[Info.ElementIndex];
863
        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
864
          Info.Name = readString(Ctx);
865
          Info.ImportName = Import.Field;
866
        } else {
867
          Info.Name = Import.Field;
868
        }
869
        Signature = &Signatures[Import.SigIndex];
870
        Info.ImportModule = Import.Module;
871
      }
872
      break;
873
    }
874

875
    default:
876
      return make_error<GenericBinaryError>("invalid symbol type: " +
877
                                                Twine(unsigned(Info.Kind)),
878
                                            object_error::parse_failed);
879
    }
880

881
    if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
882
            wasm::WASM_SYMBOL_BINDING_LOCAL &&
883
        !SymbolNames.insert(Info.Name).second)
884
      return make_error<GenericBinaryError>("duplicate symbol name " +
885
                                                Twine(Info.Name),
886
                                            object_error::parse_failed);
887
    Symbols.emplace_back(Info, GlobalType, TableType, Signature);
888
    LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
889
  }
890

891
  return Error::success();
892
}
893

894
Error WasmObjectFile::parseLinkingSectionComdat(ReadContext &Ctx) {
895
  uint32_t ComdatCount = readVaruint32(Ctx);
896
  StringSet<> ComdatSet;
897
  for (unsigned ComdatIndex = 0; ComdatIndex < ComdatCount; ++ComdatIndex) {
898
    StringRef Name = readString(Ctx);
899
    if (Name.empty() || !ComdatSet.insert(Name).second)
900
      return make_error<GenericBinaryError>("bad/duplicate COMDAT name " +
901
                                                Twine(Name),
902
                                            object_error::parse_failed);
903
    LinkingData.Comdats.emplace_back(Name);
904
    uint32_t Flags = readVaruint32(Ctx);
905
    if (Flags != 0)
906
      return make_error<GenericBinaryError>("unsupported COMDAT flags",
907
                                            object_error::parse_failed);
908

909
    uint32_t EntryCount = readVaruint32(Ctx);
910
    while (EntryCount--) {
911
      unsigned Kind = readVaruint32(Ctx);
912
      unsigned Index = readVaruint32(Ctx);
913
      switch (Kind) {
914
      default:
915
        return make_error<GenericBinaryError>("invalid COMDAT entry type",
916
                                              object_error::parse_failed);
917
      case wasm::WASM_COMDAT_DATA:
918
        if (Index >= DataSegments.size())
919
          return make_error<GenericBinaryError>(
920
              "COMDAT data index out of range", object_error::parse_failed);
921
        if (DataSegments[Index].Data.Comdat != UINT32_MAX)
922
          return make_error<GenericBinaryError>("data segment in two COMDATs",
923
                                                object_error::parse_failed);
924
        DataSegments[Index].Data.Comdat = ComdatIndex;
925
        break;
926
      case wasm::WASM_COMDAT_FUNCTION:
927
        if (!isDefinedFunctionIndex(Index))
928
          return make_error<GenericBinaryError>(
929
              "COMDAT function index out of range", object_error::parse_failed);
930
        if (getDefinedFunction(Index).Comdat != UINT32_MAX)
931
          return make_error<GenericBinaryError>("function in two COMDATs",
932
                                                object_error::parse_failed);
933
        getDefinedFunction(Index).Comdat = ComdatIndex;
934
        break;
935
      case wasm::WASM_COMDAT_SECTION:
936
        if (Index >= Sections.size())
937
          return make_error<GenericBinaryError>(
938
              "COMDAT section index out of range", object_error::parse_failed);
939
        if (Sections[Index].Type != wasm::WASM_SEC_CUSTOM)
940
          return make_error<GenericBinaryError>(
941
              "non-custom section in a COMDAT", object_error::parse_failed);
942
        Sections[Index].Comdat = ComdatIndex;
943
        break;
944
      }
945
    }
946
  }
947
  return Error::success();
948
}
949

950
Error WasmObjectFile::parseProducersSection(ReadContext &Ctx) {
951
  llvm::SmallSet<StringRef, 3> FieldsSeen;
952
  uint32_t Fields = readVaruint32(Ctx);
953
  for (size_t I = 0; I < Fields; ++I) {
954
    StringRef FieldName = readString(Ctx);
955
    if (!FieldsSeen.insert(FieldName).second)
956
      return make_error<GenericBinaryError>(
957
          "producers section does not have unique fields",
958
          object_error::parse_failed);
959
    std::vector<std::pair<std::string, std::string>> *ProducerVec = nullptr;
960
    if (FieldName == "language") {
961
      ProducerVec = &ProducerInfo.Languages;
962
    } else if (FieldName == "processed-by") {
963
      ProducerVec = &ProducerInfo.Tools;
964
    } else if (FieldName == "sdk") {
965
      ProducerVec = &ProducerInfo.SDKs;
966
    } else {
967
      return make_error<GenericBinaryError>(
968
          "producers section field is not named one of language, processed-by, "
969
          "or sdk",
970
          object_error::parse_failed);
971
    }
972
    uint32_t ValueCount = readVaruint32(Ctx);
973
    llvm::SmallSet<StringRef, 8> ProducersSeen;
974
    for (size_t J = 0; J < ValueCount; ++J) {
975
      StringRef Name = readString(Ctx);
976
      StringRef Version = readString(Ctx);
977
      if (!ProducersSeen.insert(Name).second) {
978
        return make_error<GenericBinaryError>(
979
            "producers section contains repeated producer",
980
            object_error::parse_failed);
981
      }
982
      ProducerVec->emplace_back(std::string(Name), std::string(Version));
983
    }
984
  }
985
  if (Ctx.Ptr != Ctx.End)
986
    return make_error<GenericBinaryError>("producers section ended prematurely",
987
                                          object_error::parse_failed);
988
  return Error::success();
989
}
990

991
Error WasmObjectFile::parseTargetFeaturesSection(ReadContext &Ctx) {
992
  llvm::SmallSet<std::string, 8> FeaturesSeen;
993
  uint32_t FeatureCount = readVaruint32(Ctx);
994
  for (size_t I = 0; I < FeatureCount; ++I) {
995
    wasm::WasmFeatureEntry Feature;
996
    Feature.Prefix = readUint8(Ctx);
997
    switch (Feature.Prefix) {
998
    case wasm::WASM_FEATURE_PREFIX_USED:
999
    case wasm::WASM_FEATURE_PREFIX_REQUIRED:
1000
    case wasm::WASM_FEATURE_PREFIX_DISALLOWED:
1001
      break;
1002
    default:
1003
      return make_error<GenericBinaryError>("unknown feature policy prefix",
1004
                                            object_error::parse_failed);
1005
    }
1006
    Feature.Name = std::string(readString(Ctx));
1007
    if (!FeaturesSeen.insert(Feature.Name).second)
1008
      return make_error<GenericBinaryError>(
1009
          "target features section contains repeated feature \"" +
1010
              Feature.Name + "\"",
1011
          object_error::parse_failed);
1012
    TargetFeatures.push_back(Feature);
1013
  }
1014
  if (Ctx.Ptr != Ctx.End)
1015
    return make_error<GenericBinaryError>(
1016
        "target features section ended prematurely",
1017
        object_error::parse_failed);
1018
  return Error::success();
1019
}
1020

1021
Error WasmObjectFile::parseRelocSection(StringRef Name, ReadContext &Ctx) {
1022
  uint32_t SectionIndex = readVaruint32(Ctx);
1023
  if (SectionIndex >= Sections.size())
1024
    return make_error<GenericBinaryError>("invalid section index",
1025
                                          object_error::parse_failed);
1026
  WasmSection &Section = Sections[SectionIndex];
1027
  uint32_t RelocCount = readVaruint32(Ctx);
1028
  uint32_t EndOffset = Section.Content.size();
1029
  uint32_t PreviousOffset = 0;
1030
  while (RelocCount--) {
1031
    wasm::WasmRelocation Reloc = {};
1032
    uint32_t type = readVaruint32(Ctx);
1033
    Reloc.Type = type;
1034
    Reloc.Offset = readVaruint32(Ctx);
1035
    if (Reloc.Offset < PreviousOffset)
1036
      return make_error<GenericBinaryError>("relocations not in offset order",
1037
                                            object_error::parse_failed);
1038

1039
    auto badReloc = [&](StringRef msg) {
1040
      return make_error<GenericBinaryError>(
1041
          msg + ": " + Twine(Symbols[Reloc.Index].Info.Name),
1042
          object_error::parse_failed);
1043
    };
1044

1045
    PreviousOffset = Reloc.Offset;
1046
    Reloc.Index = readVaruint32(Ctx);
1047
    switch (type) {
1048
    case wasm::R_WASM_FUNCTION_INDEX_LEB:
1049
    case wasm::R_WASM_FUNCTION_INDEX_I32:
1050
    case wasm::R_WASM_TABLE_INDEX_SLEB:
1051
    case wasm::R_WASM_TABLE_INDEX_SLEB64:
1052
    case wasm::R_WASM_TABLE_INDEX_I32:
1053
    case wasm::R_WASM_TABLE_INDEX_I64:
1054
    case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
1055
    case wasm::R_WASM_TABLE_INDEX_REL_SLEB64:
1056
      if (!isValidFunctionSymbol(Reloc.Index))
1057
        return badReloc("invalid function relocation");
1058
      break;
1059
    case wasm::R_WASM_TABLE_NUMBER_LEB:
1060
      if (!isValidTableSymbol(Reloc.Index))
1061
        return badReloc("invalid table relocation");
1062
      break;
1063
    case wasm::R_WASM_TYPE_INDEX_LEB:
1064
      if (Reloc.Index >= Signatures.size())
1065
        return badReloc("invalid relocation type index");
1066
      break;
1067
    case wasm::R_WASM_GLOBAL_INDEX_LEB:
1068
      // R_WASM_GLOBAL_INDEX_LEB are can be used against function and data
1069
      // symbols to refer to their GOT entries.
1070
      if (!isValidGlobalSymbol(Reloc.Index) &&
1071
          !isValidDataSymbol(Reloc.Index) &&
1072
          !isValidFunctionSymbol(Reloc.Index))
1073
        return badReloc("invalid global relocation");
1074
      break;
1075
    case wasm::R_WASM_GLOBAL_INDEX_I32:
1076
      if (!isValidGlobalSymbol(Reloc.Index))
1077
        return badReloc("invalid global relocation");
1078
      break;
1079
    case wasm::R_WASM_TAG_INDEX_LEB:
1080
      if (!isValidTagSymbol(Reloc.Index))
1081
        return badReloc("invalid tag relocation");
1082
      break;
1083
    case wasm::R_WASM_MEMORY_ADDR_LEB:
1084
    case wasm::R_WASM_MEMORY_ADDR_SLEB:
1085
    case wasm::R_WASM_MEMORY_ADDR_I32:
1086
    case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
1087
    case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
1088
    case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
1089
      if (!isValidDataSymbol(Reloc.Index))
1090
        return badReloc("invalid data relocation");
1091
      Reloc.Addend = readVarint32(Ctx);
1092
      break;
1093
    case wasm::R_WASM_MEMORY_ADDR_LEB64:
1094
    case wasm::R_WASM_MEMORY_ADDR_SLEB64:
1095
    case wasm::R_WASM_MEMORY_ADDR_I64:
1096
    case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
1097
    case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB64:
1098
      if (!isValidDataSymbol(Reloc.Index))
1099
        return badReloc("invalid data relocation");
1100
      Reloc.Addend = readVarint64(Ctx);
1101
      break;
1102
    case wasm::R_WASM_FUNCTION_OFFSET_I32:
1103
      if (!isValidFunctionSymbol(Reloc.Index))
1104
        return badReloc("invalid function relocation");
1105
      Reloc.Addend = readVarint32(Ctx);
1106
      break;
1107
    case wasm::R_WASM_FUNCTION_OFFSET_I64:
1108
      if (!isValidFunctionSymbol(Reloc.Index))
1109
        return badReloc("invalid function relocation");
1110
      Reloc.Addend = readVarint64(Ctx);
1111
      break;
1112
    case wasm::R_WASM_SECTION_OFFSET_I32:
1113
      if (!isValidSectionSymbol(Reloc.Index))
1114
        return badReloc("invalid section relocation");
1115
      Reloc.Addend = readVarint32(Ctx);
1116
      break;
1117
    default:
1118
      return make_error<GenericBinaryError>("invalid relocation type: " +
1119
                                                Twine(type),
1120
                                            object_error::parse_failed);
1121
    }
1122

1123
    // Relocations must fit inside the section, and must appear in order.  They
1124
    // also shouldn't overlap a function/element boundary, but we don't bother
1125
    // to check that.
1126
    uint64_t Size = 5;
1127
    if (Reloc.Type == wasm::R_WASM_MEMORY_ADDR_LEB64 ||
1128
        Reloc.Type == wasm::R_WASM_MEMORY_ADDR_SLEB64 ||
1129
        Reloc.Type == wasm::R_WASM_MEMORY_ADDR_REL_SLEB64)
1130
      Size = 10;
1131
    if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I32 ||
1132
        Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I32 ||
1133
        Reloc.Type == wasm::R_WASM_MEMORY_ADDR_LOCREL_I32 ||
1134
        Reloc.Type == wasm::R_WASM_SECTION_OFFSET_I32 ||
1135
        Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
1136
        Reloc.Type == wasm::R_WASM_FUNCTION_INDEX_I32 ||
1137
        Reloc.Type == wasm::R_WASM_GLOBAL_INDEX_I32)
1138
      Size = 4;
1139
    if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I64 ||
1140
        Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I64 ||
1141
        Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I64)
1142
      Size = 8;
1143
    if (Reloc.Offset + Size > EndOffset)
1144
      return make_error<GenericBinaryError>("invalid relocation offset",
1145
                                            object_error::parse_failed);
1146

1147
    Section.Relocations.push_back(Reloc);
1148
  }
1149
  if (Ctx.Ptr != Ctx.End)
1150
    return make_error<GenericBinaryError>("reloc section ended prematurely",
1151
                                          object_error::parse_failed);
1152
  return Error::success();
1153
}
1154

1155
Error WasmObjectFile::parseCustomSection(WasmSection &Sec, ReadContext &Ctx) {
1156
  if (Sec.Name == "dylink") {
1157
    if (Error Err = parseDylinkSection(Ctx))
1158
      return Err;
1159
  } else if (Sec.Name == "dylink.0") {
1160
    if (Error Err = parseDylink0Section(Ctx))
1161
      return Err;
1162
  } else if (Sec.Name == "name") {
1163
    if (Error Err = parseNameSection(Ctx))
1164
      return Err;
1165
  } else if (Sec.Name == "linking") {
1166
    if (Error Err = parseLinkingSection(Ctx))
1167
      return Err;
1168
  } else if (Sec.Name == "producers") {
1169
    if (Error Err = parseProducersSection(Ctx))
1170
      return Err;
1171
  } else if (Sec.Name == "target_features") {
1172
    if (Error Err = parseTargetFeaturesSection(Ctx))
1173
      return Err;
1174
  } else if (Sec.Name.starts_with("reloc.")) {
1175
    if (Error Err = parseRelocSection(Sec.Name, Ctx))
1176
      return Err;
1177
  }
1178
  return Error::success();
1179
}
1180

1181
Error WasmObjectFile::parseTypeSection(ReadContext &Ctx) {
1182
  auto parseFieldDef = [&]() {
1183
    uint32_t TypeCode = readVaruint32((Ctx));
1184
    /* Discard StorageType */ parseValType(Ctx, TypeCode);
1185
    /* Discard Mutability */ readVaruint32(Ctx);
1186
  };
1187

1188
  uint32_t Count = readVaruint32(Ctx);
1189
  Signatures.reserve(Count);
1190
  while (Count--) {
1191
    wasm::WasmSignature Sig;
1192
    uint8_t Form = readUint8(Ctx);
1193
    if (Form == wasm::WASM_TYPE_REC) {
1194
      // Rec groups expand the type index space (beyond what was declared at
1195
      // the top of the section, and also consume one element in that space.
1196
      uint32_t RecSize = readVaruint32(Ctx);
1197
      if (RecSize == 0)
1198
        return make_error<GenericBinaryError>("Rec group size cannot be 0",
1199
                                              object_error::parse_failed);
1200
      Signatures.reserve(Signatures.size() + RecSize);
1201
      Count += RecSize;
1202
      Sig.Kind = wasm::WasmSignature::Placeholder;
1203
      Signatures.push_back(std::move(Sig));
1204
      HasUnmodeledTypes = true;
1205
      continue;
1206
    }
1207
    if (Form != wasm::WASM_TYPE_FUNC) {
1208
      // Currently LLVM only models function types, and not other composite
1209
      // types. Here we parse the type declarations just enough to skip past
1210
      // them in the binary.
1211
      if (Form == wasm::WASM_TYPE_SUB || Form == wasm::WASM_TYPE_SUB_FINAL) {
1212
        uint32_t Supers = readVaruint32(Ctx);
1213
        if (Supers > 0) {
1214
          if (Supers != 1)
1215
            return make_error<GenericBinaryError>(
1216
                "Invalid number of supertypes", object_error::parse_failed);
1217
          /* Discard SuperIndex */ readVaruint32(Ctx);
1218
        }
1219
        Form = readVaruint32(Ctx);
1220
      }
1221
      if (Form == wasm::WASM_TYPE_STRUCT) {
1222
        uint32_t FieldCount = readVaruint32(Ctx);
1223
        while (FieldCount--) {
1224
          parseFieldDef();
1225
        }
1226
      } else if (Form == wasm::WASM_TYPE_ARRAY) {
1227
        parseFieldDef();
1228
      } else {
1229
        return make_error<GenericBinaryError>("bad form",
1230
                                              object_error::parse_failed);
1231
      }
1232
      Sig.Kind = wasm::WasmSignature::Placeholder;
1233
      Signatures.push_back(std::move(Sig));
1234
      HasUnmodeledTypes = true;
1235
      continue;
1236
    }
1237

1238
    uint32_t ParamCount = readVaruint32(Ctx);
1239
    Sig.Params.reserve(ParamCount);
1240
    while (ParamCount--) {
1241
      uint32_t ParamType = readUint8(Ctx);
1242
      Sig.Params.push_back(parseValType(Ctx, ParamType));
1243
      continue;
1244
    }
1245
    uint32_t ReturnCount = readVaruint32(Ctx);
1246
    while (ReturnCount--) {
1247
      uint32_t ReturnType = readUint8(Ctx);
1248
      Sig.Returns.push_back(parseValType(Ctx, ReturnType));
1249
    }
1250

1251
    Signatures.push_back(std::move(Sig));
1252
  }
1253
  if (Ctx.Ptr != Ctx.End)
1254
    return make_error<GenericBinaryError>("type section ended prematurely",
1255
                                          object_error::parse_failed);
1256
  return Error::success();
1257
}
1258

1259
Error WasmObjectFile::parseImportSection(ReadContext &Ctx) {
1260
  uint32_t Count = readVaruint32(Ctx);
1261
  uint32_t NumTypes = Signatures.size();
1262
  Imports.reserve(Count);
1263
  for (uint32_t I = 0; I < Count; I++) {
1264
    wasm::WasmImport Im;
1265
    Im.Module = readString(Ctx);
1266
    Im.Field = readString(Ctx);
1267
    Im.Kind = readUint8(Ctx);
1268
    switch (Im.Kind) {
1269
    case wasm::WASM_EXTERNAL_FUNCTION:
1270
      NumImportedFunctions++;
1271
      Im.SigIndex = readVaruint32(Ctx);
1272
      if (Im.SigIndex >= NumTypes)
1273
        return make_error<GenericBinaryError>("invalid function type",
1274
                                              object_error::parse_failed);
1275
      break;
1276
    case wasm::WASM_EXTERNAL_GLOBAL:
1277
      NumImportedGlobals++;
1278
      Im.Global.Type = readUint8(Ctx);
1279
      Im.Global.Mutable = readVaruint1(Ctx);
1280
      break;
1281
    case wasm::WASM_EXTERNAL_MEMORY:
1282
      Im.Memory = readLimits(Ctx);
1283
      if (Im.Memory.Flags & wasm::WASM_LIMITS_FLAG_IS_64)
1284
        HasMemory64 = true;
1285
      break;
1286
    case wasm::WASM_EXTERNAL_TABLE: {
1287
      Im.Table = readTableType(Ctx);
1288
      NumImportedTables++;
1289
      auto ElemType = Im.Table.ElemType;
1290
      if (ElemType != wasm::ValType::FUNCREF &&
1291
          ElemType != wasm::ValType::EXTERNREF &&
1292
          ElemType != wasm::ValType::EXNREF &&
1293
          ElemType != wasm::ValType::OTHERREF)
1294
        return make_error<GenericBinaryError>("invalid table element type",
1295
                                              object_error::parse_failed);
1296
      break;
1297
    }
1298
    case wasm::WASM_EXTERNAL_TAG:
1299
      NumImportedTags++;
1300
      if (readUint8(Ctx) != 0) // Reserved 'attribute' field
1301
        return make_error<GenericBinaryError>("invalid attribute",
1302
                                              object_error::parse_failed);
1303
      Im.SigIndex = readVaruint32(Ctx);
1304
      if (Im.SigIndex >= NumTypes)
1305
        return make_error<GenericBinaryError>("invalid tag type",
1306
                                              object_error::parse_failed);
1307
      break;
1308
    default:
1309
      return make_error<GenericBinaryError>("unexpected import kind",
1310
                                            object_error::parse_failed);
1311
    }
1312
    Imports.push_back(Im);
1313
  }
1314
  if (Ctx.Ptr != Ctx.End)
1315
    return make_error<GenericBinaryError>("import section ended prematurely",
1316
                                          object_error::parse_failed);
1317
  return Error::success();
1318
}
1319

1320
Error WasmObjectFile::parseFunctionSection(ReadContext &Ctx) {
1321
  uint32_t Count = readVaruint32(Ctx);
1322
  Functions.reserve(Count);
1323
  uint32_t NumTypes = Signatures.size();
1324
  while (Count--) {
1325
    uint32_t Type = readVaruint32(Ctx);
1326
    if (Type >= NumTypes)
1327
      return make_error<GenericBinaryError>("invalid function type",
1328
                                            object_error::parse_failed);
1329
    wasm::WasmFunction F;
1330
    F.SigIndex = Type;
1331
    Functions.push_back(F);
1332
  }
1333
  if (Ctx.Ptr != Ctx.End)
1334
    return make_error<GenericBinaryError>("function section ended prematurely",
1335
                                          object_error::parse_failed);
1336
  return Error::success();
1337
}
1338

1339
Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
1340
  TableSection = Sections.size();
1341
  uint32_t Count = readVaruint32(Ctx);
1342
  Tables.reserve(Count);
1343
  while (Count--) {
1344
    wasm::WasmTable T;
1345
    T.Type = readTableType(Ctx);
1346
    T.Index = NumImportedTables + Tables.size();
1347
    Tables.push_back(T);
1348
    auto ElemType = Tables.back().Type.ElemType;
1349
    if (ElemType != wasm::ValType::FUNCREF &&
1350
        ElemType != wasm::ValType::EXTERNREF &&
1351
        ElemType != wasm::ValType::EXNREF &&
1352
        ElemType != wasm::ValType::OTHERREF) {
1353
      return make_error<GenericBinaryError>("invalid table element type",
1354
                                            object_error::parse_failed);
1355
    }
1356
  }
1357
  if (Ctx.Ptr != Ctx.End)
1358
    return make_error<GenericBinaryError>("table section ended prematurely",
1359
                                          object_error::parse_failed);
1360
  return Error::success();
1361
}
1362

1363
Error WasmObjectFile::parseMemorySection(ReadContext &Ctx) {
1364
  uint32_t Count = readVaruint32(Ctx);
1365
  Memories.reserve(Count);
1366
  while (Count--) {
1367
    auto Limits = readLimits(Ctx);
1368
    if (Limits.Flags & wasm::WASM_LIMITS_FLAG_IS_64)
1369
      HasMemory64 = true;
1370
    Memories.push_back(Limits);
1371
  }
1372
  if (Ctx.Ptr != Ctx.End)
1373
    return make_error<GenericBinaryError>("memory section ended prematurely",
1374
                                          object_error::parse_failed);
1375
  return Error::success();
1376
}
1377

1378
Error WasmObjectFile::parseTagSection(ReadContext &Ctx) {
1379
  TagSection = Sections.size();
1380
  uint32_t Count = readVaruint32(Ctx);
1381
  Tags.reserve(Count);
1382
  uint32_t NumTypes = Signatures.size();
1383
  while (Count--) {
1384
    if (readUint8(Ctx) != 0) // Reserved 'attribute' field
1385
      return make_error<GenericBinaryError>("invalid attribute",
1386
                                            object_error::parse_failed);
1387
    uint32_t Type = readVaruint32(Ctx);
1388
    if (Type >= NumTypes)
1389
      return make_error<GenericBinaryError>("invalid tag type",
1390
                                            object_error::parse_failed);
1391
    wasm::WasmTag Tag;
1392
    Tag.Index = NumImportedTags + Tags.size();
1393
    Tag.SigIndex = Type;
1394
    Signatures[Type].Kind = wasm::WasmSignature::Tag;
1395
    Tags.push_back(Tag);
1396
  }
1397

1398
  if (Ctx.Ptr != Ctx.End)
1399
    return make_error<GenericBinaryError>("tag section ended prematurely",
1400
                                          object_error::parse_failed);
1401
  return Error::success();
1402
}
1403

1404
Error WasmObjectFile::parseGlobalSection(ReadContext &Ctx) {
1405
  GlobalSection = Sections.size();
1406
  const uint8_t *SectionStart = Ctx.Ptr;
1407
  uint32_t Count = readVaruint32(Ctx);
1408
  Globals.reserve(Count);
1409
  while (Count--) {
1410
    wasm::WasmGlobal Global;
1411
    Global.Index = NumImportedGlobals + Globals.size();
1412
    const uint8_t *GlobalStart = Ctx.Ptr;
1413
    Global.Offset = static_cast<uint32_t>(GlobalStart - SectionStart);
1414
    auto GlobalOpcode = readVaruint32(Ctx);
1415
    Global.Type.Type = (uint8_t)parseValType(Ctx, GlobalOpcode);
1416
    Global.Type.Mutable = readVaruint1(Ctx);
1417
    if (Error Err = readInitExpr(Global.InitExpr, Ctx))
1418
      return Err;
1419
    Global.Size = static_cast<uint32_t>(Ctx.Ptr - GlobalStart);
1420
    Globals.push_back(Global);
1421
  }
1422
  if (Ctx.Ptr != Ctx.End)
1423
    return make_error<GenericBinaryError>("global section ended prematurely",
1424
                                          object_error::parse_failed);
1425
  return Error::success();
1426
}
1427

1428
Error WasmObjectFile::parseExportSection(ReadContext &Ctx) {
1429
  uint32_t Count = readVaruint32(Ctx);
1430
  Exports.reserve(Count);
1431
  Symbols.reserve(Count);
1432
  for (uint32_t I = 0; I < Count; I++) {
1433
    wasm::WasmExport Ex;
1434
    Ex.Name = readString(Ctx);
1435
    Ex.Kind = readUint8(Ctx);
1436
    Ex.Index = readVaruint32(Ctx);
1437
    const wasm::WasmSignature *Signature = nullptr;
1438
    const wasm::WasmGlobalType *GlobalType = nullptr;
1439
    const wasm::WasmTableType *TableType = nullptr;
1440
    wasm::WasmSymbolInfo Info;
1441
    Info.Name = Ex.Name;
1442
    Info.Flags = 0;
1443
    switch (Ex.Kind) {
1444
    case wasm::WASM_EXTERNAL_FUNCTION: {
1445
      if (!isDefinedFunctionIndex(Ex.Index))
1446
        return make_error<GenericBinaryError>("invalid function export",
1447
                                              object_error::parse_failed);
1448
      getDefinedFunction(Ex.Index).ExportName = Ex.Name;
1449
      Info.Kind = wasm::WASM_SYMBOL_TYPE_FUNCTION;
1450
      Info.ElementIndex = Ex.Index;
1451
      unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
1452
      wasm::WasmFunction &Function = Functions[FuncIndex];
1453
      Signature = &Signatures[Function.SigIndex];
1454
      break;
1455
    }
1456
    case wasm::WASM_EXTERNAL_GLOBAL: {
1457
      if (!isValidGlobalIndex(Ex.Index))
1458
        return make_error<GenericBinaryError>("invalid global export",
1459
                                              object_error::parse_failed);
1460
      Info.Kind = wasm::WASM_SYMBOL_TYPE_DATA;
1461
      uint64_t Offset = 0;
1462
      if (isDefinedGlobalIndex(Ex.Index)) {
1463
        auto Global = getDefinedGlobal(Ex.Index);
1464
        if (!Global.InitExpr.Extended) {
1465
          auto Inst = Global.InitExpr.Inst;
1466
          if (Inst.Opcode == wasm::WASM_OPCODE_I32_CONST) {
1467
            Offset = Inst.Value.Int32;
1468
          } else if (Inst.Opcode == wasm::WASM_OPCODE_I64_CONST) {
1469
            Offset = Inst.Value.Int64;
1470
          }
1471
        }
1472
      }
1473
      Info.DataRef = wasm::WasmDataReference{0, Offset, 0};
1474
      break;
1475
    }
1476
    case wasm::WASM_EXTERNAL_TAG:
1477
      if (!isValidTagIndex(Ex.Index))
1478
        return make_error<GenericBinaryError>("invalid tag export",
1479
                                              object_error::parse_failed);
1480
      Info.Kind = wasm::WASM_SYMBOL_TYPE_TAG;
1481
      Info.ElementIndex = Ex.Index;
1482
      break;
1483
    case wasm::WASM_EXTERNAL_MEMORY:
1484
      break;
1485
    case wasm::WASM_EXTERNAL_TABLE:
1486
      Info.Kind = wasm::WASM_SYMBOL_TYPE_TABLE;
1487
      Info.ElementIndex = Ex.Index;
1488
      break;
1489
    default:
1490
      return make_error<GenericBinaryError>("unexpected export kind",
1491
                                            object_error::parse_failed);
1492
    }
1493
    Exports.push_back(Ex);
1494
    if (Ex.Kind != wasm::WASM_EXTERNAL_MEMORY) {
1495
      Symbols.emplace_back(Info, GlobalType, TableType, Signature);
1496
      LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
1497
    }
1498
  }
1499
  if (Ctx.Ptr != Ctx.End)
1500
    return make_error<GenericBinaryError>("export section ended prematurely",
1501
                                          object_error::parse_failed);
1502
  return Error::success();
1503
}
1504

1505
bool WasmObjectFile::isValidFunctionIndex(uint32_t Index) const {
1506
  return Index < NumImportedFunctions + Functions.size();
1507
}
1508

1509
bool WasmObjectFile::isDefinedFunctionIndex(uint32_t Index) const {
1510
  return Index >= NumImportedFunctions && isValidFunctionIndex(Index);
1511
}
1512

1513
bool WasmObjectFile::isValidGlobalIndex(uint32_t Index) const {
1514
  return Index < NumImportedGlobals + Globals.size();
1515
}
1516

1517
bool WasmObjectFile::isValidTableNumber(uint32_t Index) const {
1518
  return Index < NumImportedTables + Tables.size();
1519
}
1520

1521
bool WasmObjectFile::isDefinedGlobalIndex(uint32_t Index) const {
1522
  return Index >= NumImportedGlobals && isValidGlobalIndex(Index);
1523
}
1524

1525
bool WasmObjectFile::isDefinedTableNumber(uint32_t Index) const {
1526
  return Index >= NumImportedTables && isValidTableNumber(Index);
1527
}
1528

1529
bool WasmObjectFile::isValidTagIndex(uint32_t Index) const {
1530
  return Index < NumImportedTags + Tags.size();
1531
}
1532

1533
bool WasmObjectFile::isDefinedTagIndex(uint32_t Index) const {
1534
  return Index >= NumImportedTags && isValidTagIndex(Index);
1535
}
1536

1537
bool WasmObjectFile::isValidFunctionSymbol(uint32_t Index) const {
1538
  return Index < Symbols.size() && Symbols[Index].isTypeFunction();
1539
}
1540

1541
bool WasmObjectFile::isValidTableSymbol(uint32_t Index) const {
1542
  return Index < Symbols.size() && Symbols[Index].isTypeTable();
1543
}
1544

1545
bool WasmObjectFile::isValidGlobalSymbol(uint32_t Index) const {
1546
  return Index < Symbols.size() && Symbols[Index].isTypeGlobal();
1547
}
1548

1549
bool WasmObjectFile::isValidTagSymbol(uint32_t Index) const {
1550
  return Index < Symbols.size() && Symbols[Index].isTypeTag();
1551
}
1552

1553
bool WasmObjectFile::isValidDataSymbol(uint32_t Index) const {
1554
  return Index < Symbols.size() && Symbols[Index].isTypeData();
1555
}
1556

1557
bool WasmObjectFile::isValidSectionSymbol(uint32_t Index) const {
1558
  return Index < Symbols.size() && Symbols[Index].isTypeSection();
1559
}
1560

1561
wasm::WasmFunction &WasmObjectFile::getDefinedFunction(uint32_t Index) {
1562
  assert(isDefinedFunctionIndex(Index));
1563
  return Functions[Index - NumImportedFunctions];
1564
}
1565

1566
const wasm::WasmFunction &
1567
WasmObjectFile::getDefinedFunction(uint32_t Index) const {
1568
  assert(isDefinedFunctionIndex(Index));
1569
  return Functions[Index - NumImportedFunctions];
1570
}
1571

1572
const wasm::WasmGlobal &WasmObjectFile::getDefinedGlobal(uint32_t Index) const {
1573
  assert(isDefinedGlobalIndex(Index));
1574
  return Globals[Index - NumImportedGlobals];
1575
}
1576

1577
wasm::WasmTag &WasmObjectFile::getDefinedTag(uint32_t Index) {
1578
  assert(isDefinedTagIndex(Index));
1579
  return Tags[Index - NumImportedTags];
1580
}
1581

1582
Error WasmObjectFile::parseStartSection(ReadContext &Ctx) {
1583
  StartFunction = readVaruint32(Ctx);
1584
  if (!isValidFunctionIndex(StartFunction))
1585
    return make_error<GenericBinaryError>("invalid start function",
1586
                                          object_error::parse_failed);
1587
  return Error::success();
1588
}
1589

1590
Error WasmObjectFile::parseCodeSection(ReadContext &Ctx) {
1591
  CodeSection = Sections.size();
1592
  uint32_t FunctionCount = readVaruint32(Ctx);
1593
  if (FunctionCount != Functions.size()) {
1594
    return make_error<GenericBinaryError>("invalid function count",
1595
                                          object_error::parse_failed);
1596
  }
1597

1598
  for (uint32_t i = 0; i < FunctionCount; i++) {
1599
    wasm::WasmFunction& Function = Functions[i];
1600
    const uint8_t *FunctionStart = Ctx.Ptr;
1601
    uint32_t Size = readVaruint32(Ctx);
1602
    const uint8_t *FunctionEnd = Ctx.Ptr + Size;
1603

1604
    Function.CodeOffset = Ctx.Ptr - FunctionStart;
1605
    Function.Index = NumImportedFunctions + i;
1606
    Function.CodeSectionOffset = FunctionStart - Ctx.Start;
1607
    Function.Size = FunctionEnd - FunctionStart;
1608

1609
    uint32_t NumLocalDecls = readVaruint32(Ctx);
1610
    Function.Locals.reserve(NumLocalDecls);
1611
    while (NumLocalDecls--) {
1612
      wasm::WasmLocalDecl Decl;
1613
      Decl.Count = readVaruint32(Ctx);
1614
      Decl.Type = readUint8(Ctx);
1615
      Function.Locals.push_back(Decl);
1616
    }
1617

1618
    uint32_t BodySize = FunctionEnd - Ctx.Ptr;
1619
    // Ensure that Function is within Ctx's buffer.
1620
    if (Ctx.Ptr + BodySize > Ctx.End) {
1621
      return make_error<GenericBinaryError>("Function extends beyond buffer",
1622
                                            object_error::parse_failed);
1623
    }
1624
    Function.Body = ArrayRef<uint8_t>(Ctx.Ptr, BodySize);
1625
    // This will be set later when reading in the linking metadata section.
1626
    Function.Comdat = UINT32_MAX;
1627
    Ctx.Ptr += BodySize;
1628
    assert(Ctx.Ptr == FunctionEnd);
1629
  }
1630
  if (Ctx.Ptr != Ctx.End)
1631
    return make_error<GenericBinaryError>("code section ended prematurely",
1632
                                          object_error::parse_failed);
1633
  return Error::success();
1634
}
1635

1636
Error WasmObjectFile::parseElemSection(ReadContext &Ctx) {
1637
  uint32_t Count = readVaruint32(Ctx);
1638
  ElemSegments.reserve(Count);
1639
  while (Count--) {
1640
    wasm::WasmElemSegment Segment;
1641
    Segment.Flags = readVaruint32(Ctx);
1642

1643
    uint32_t SupportedFlags = wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER |
1644
                              wasm::WASM_ELEM_SEGMENT_IS_PASSIVE |
1645
                              wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS;
1646
    if (Segment.Flags & ~SupportedFlags)
1647
      return make_error<GenericBinaryError>(
1648
          "Unsupported flags for element segment", object_error::parse_failed);
1649

1650
    bool IsPassive = (Segment.Flags & wasm::WASM_ELEM_SEGMENT_IS_PASSIVE) != 0;
1651
    bool IsDeclarative =
1652
        IsPassive && (Segment.Flags & wasm::WASM_ELEM_SEGMENT_IS_DECLARATIVE);
1653
    bool HasTableNumber =
1654
        !IsPassive &&
1655
        (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER);
1656
    bool HasInitExprs =
1657
        (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS);
1658
    bool HasElemKind =
1659
        (Segment.Flags & wasm::WASM_ELEM_SEGMENT_MASK_HAS_ELEM_KIND) &&
1660
        !HasInitExprs;
1661

1662
    if (HasTableNumber)
1663
      Segment.TableNumber = readVaruint32(Ctx);
1664
    else
1665
      Segment.TableNumber = 0;
1666

1667
    if (!isValidTableNumber(Segment.TableNumber))
1668
      return make_error<GenericBinaryError>("invalid TableNumber",
1669
                                            object_error::parse_failed);
1670

1671
    if (IsPassive || IsDeclarative) {
1672
      Segment.Offset.Extended = false;
1673
      Segment.Offset.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
1674
      Segment.Offset.Inst.Value.Int32 = 0;
1675
    } else {
1676
      if (Error Err = readInitExpr(Segment.Offset, Ctx))
1677
        return Err;
1678
    }
1679

1680
    if (HasElemKind) {
1681
      auto ElemKind = readVaruint32(Ctx);
1682
      if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS) {
1683
        Segment.ElemKind = parseValType(Ctx, ElemKind);
1684
        if (Segment.ElemKind != wasm::ValType::FUNCREF &&
1685
            Segment.ElemKind != wasm::ValType::EXTERNREF &&
1686
            Segment.ElemKind != wasm::ValType::EXNREF &&
1687
            Segment.ElemKind != wasm::ValType::OTHERREF) {
1688
          return make_error<GenericBinaryError>("invalid elem type",
1689
                                                object_error::parse_failed);
1690
        }
1691
      } else {
1692
        if (ElemKind != 0)
1693
          return make_error<GenericBinaryError>("invalid elem type",
1694
                                                object_error::parse_failed);
1695
        Segment.ElemKind = wasm::ValType::FUNCREF;
1696
      }
1697
    } else if (HasInitExprs) {
1698
      auto ElemType = parseValType(Ctx, readVaruint32(Ctx));
1699
      Segment.ElemKind = ElemType;
1700
    } else {
1701
      Segment.ElemKind = wasm::ValType::FUNCREF;
1702
    }
1703

1704
    uint32_t NumElems = readVaruint32(Ctx);
1705

1706
    if (HasInitExprs) {
1707
      while (NumElems--) {
1708
        wasm::WasmInitExpr Expr;
1709
        if (Error Err = readInitExpr(Expr, Ctx))
1710
          return Err;
1711
      }
1712
    } else {
1713
      while (NumElems--) {
1714
        Segment.Functions.push_back(readVaruint32(Ctx));
1715
      }
1716
    }
1717
    ElemSegments.push_back(Segment);
1718
  }
1719
  if (Ctx.Ptr != Ctx.End)
1720
    return make_error<GenericBinaryError>("elem section ended prematurely",
1721
                                          object_error::parse_failed);
1722
  return Error::success();
1723
}
1724

1725
Error WasmObjectFile::parseDataSection(ReadContext &Ctx) {
1726
  DataSection = Sections.size();
1727
  uint32_t Count = readVaruint32(Ctx);
1728
  if (DataCount && Count != *DataCount)
1729
    return make_error<GenericBinaryError>(
1730
        "number of data segments does not match DataCount section");
1731
  DataSegments.reserve(Count);
1732
  while (Count--) {
1733
    WasmSegment Segment;
1734
    Segment.Data.InitFlags = readVaruint32(Ctx);
1735
    Segment.Data.MemoryIndex =
1736
        (Segment.Data.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX)
1737
            ? readVaruint32(Ctx)
1738
            : 0;
1739
    if ((Segment.Data.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
1740
      if (Error Err = readInitExpr(Segment.Data.Offset, Ctx))
1741
        return Err;
1742
    } else {
1743
      Segment.Data.Offset.Extended = false;
1744
      Segment.Data.Offset.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
1745
      Segment.Data.Offset.Inst.Value.Int32 = 0;
1746
    }
1747
    uint32_t Size = readVaruint32(Ctx);
1748
    if (Size > (size_t)(Ctx.End - Ctx.Ptr))
1749
      return make_error<GenericBinaryError>("invalid segment size",
1750
                                            object_error::parse_failed);
1751
    Segment.Data.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
1752
    // The rest of these Data fields are set later, when reading in the linking
1753
    // metadata section.
1754
    Segment.Data.Alignment = 0;
1755
    Segment.Data.LinkingFlags = 0;
1756
    Segment.Data.Comdat = UINT32_MAX;
1757
    Segment.SectionOffset = Ctx.Ptr - Ctx.Start;
1758
    Ctx.Ptr += Size;
1759
    DataSegments.push_back(Segment);
1760
  }
1761
  if (Ctx.Ptr != Ctx.End)
1762
    return make_error<GenericBinaryError>("data section ended prematurely",
1763
                                          object_error::parse_failed);
1764
  return Error::success();
1765
}
1766

1767
Error WasmObjectFile::parseDataCountSection(ReadContext &Ctx) {
1768
  DataCount = readVaruint32(Ctx);
1769
  return Error::success();
1770
}
1771

1772
const wasm::WasmObjectHeader &WasmObjectFile::getHeader() const {
1773
  return Header;
1774
}
1775

1776
void WasmObjectFile::moveSymbolNext(DataRefImpl &Symb) const { Symb.d.b++; }
1777

1778
Expected<uint32_t> WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
1779
  uint32_t Result = SymbolRef::SF_None;
1780
  const WasmSymbol &Sym = getWasmSymbol(Symb);
1781

1782
  LLVM_DEBUG(dbgs() << "getSymbolFlags: ptr=" << &Sym << " " << Sym << "\n");
1783
  if (Sym.isBindingWeak())
1784
    Result |= SymbolRef::SF_Weak;
1785
  if (!Sym.isBindingLocal())
1786
    Result |= SymbolRef::SF_Global;
1787
  if (Sym.isHidden())
1788
    Result |= SymbolRef::SF_Hidden;
1789
  if (!Sym.isDefined())
1790
    Result |= SymbolRef::SF_Undefined;
1791
  if (Sym.isTypeFunction())
1792
    Result |= SymbolRef::SF_Executable;
1793
  return Result;
1794
}
1795

1796
basic_symbol_iterator WasmObjectFile::symbol_begin() const {
1797
  DataRefImpl Ref;
1798
  Ref.d.a = 1; // Arbitrary non-zero value so that Ref.p is non-null
1799
  Ref.d.b = 0; // Symbol index
1800
  return BasicSymbolRef(Ref, this);
1801
}
1802

1803
basic_symbol_iterator WasmObjectFile::symbol_end() const {
1804
  DataRefImpl Ref;
1805
  Ref.d.a = 1; // Arbitrary non-zero value so that Ref.p is non-null
1806
  Ref.d.b = Symbols.size(); // Symbol index
1807
  return BasicSymbolRef(Ref, this);
1808
}
1809

1810
const WasmSymbol &WasmObjectFile::getWasmSymbol(const DataRefImpl &Symb) const {
1811
  return Symbols[Symb.d.b];
1812
}
1813

1814
const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
1815
  return getWasmSymbol(Symb.getRawDataRefImpl());
1816
}
1817

1818
Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
1819
  return getWasmSymbol(Symb).Info.Name;
1820
}
1821

1822
Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
1823
  auto &Sym = getWasmSymbol(Symb);
1824
  if (!Sym.isDefined())
1825
    return 0;
1826
  Expected<section_iterator> Sec = getSymbolSection(Symb);
1827
  if (!Sec)
1828
    return Sec.takeError();
1829
  uint32_t SectionAddress = getSectionAddress(Sec.get()->getRawDataRefImpl());
1830
  if (Sym.Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION &&
1831
      isDefinedFunctionIndex(Sym.Info.ElementIndex)) {
1832
    return getDefinedFunction(Sym.Info.ElementIndex).CodeSectionOffset +
1833
           SectionAddress;
1834
  }
1835
  if (Sym.Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL &&
1836
      isDefinedGlobalIndex(Sym.Info.ElementIndex)) {
1837
    return getDefinedGlobal(Sym.Info.ElementIndex).Offset + SectionAddress;
1838
  }
1839

1840
  return getSymbolValue(Symb);
1841
}
1842

1843
uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol &Sym) const {
1844
  switch (Sym.Info.Kind) {
1845
  case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1846
  case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1847
  case wasm::WASM_SYMBOL_TYPE_TAG:
1848
  case wasm::WASM_SYMBOL_TYPE_TABLE:
1849
    return Sym.Info.ElementIndex;
1850
  case wasm::WASM_SYMBOL_TYPE_DATA: {
1851
    // The value of a data symbol is the segment offset, plus the symbol
1852
    // offset within the segment.
1853
    uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
1854
    const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
1855
    if (Segment.Offset.Extended) {
1856
      llvm_unreachable("extended init exprs not supported");
1857
    } else if (Segment.Offset.Inst.Opcode == wasm::WASM_OPCODE_I32_CONST) {
1858
      return Segment.Offset.Inst.Value.Int32 + Sym.Info.DataRef.Offset;
1859
    } else if (Segment.Offset.Inst.Opcode == wasm::WASM_OPCODE_I64_CONST) {
1860
      return Segment.Offset.Inst.Value.Int64 + Sym.Info.DataRef.Offset;
1861
    } else if (Segment.Offset.Inst.Opcode == wasm::WASM_OPCODE_GLOBAL_GET) {
1862
      return Sym.Info.DataRef.Offset;
1863
    } else {
1864
      llvm_unreachable("unknown init expr opcode");
1865
    }
1866
  }
1867
  case wasm::WASM_SYMBOL_TYPE_SECTION:
1868
    return 0;
1869
  }
1870
  llvm_unreachable("invalid symbol type");
1871
}
1872

1873
uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
1874
  return getWasmSymbolValue(getWasmSymbol(Symb));
1875
}
1876

1877
uint32_t WasmObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
1878
  llvm_unreachable("not yet implemented");
1879
  return 0;
1880
}
1881

1882
uint64_t WasmObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
1883
  llvm_unreachable("not yet implemented");
1884
  return 0;
1885
}
1886

1887
Expected<SymbolRef::Type>
1888
WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
1889
  const WasmSymbol &Sym = getWasmSymbol(Symb);
1890

1891
  switch (Sym.Info.Kind) {
1892
  case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1893
    return SymbolRef::ST_Function;
1894
  case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1895
    return SymbolRef::ST_Other;
1896
  case wasm::WASM_SYMBOL_TYPE_DATA:
1897
    return SymbolRef::ST_Data;
1898
  case wasm::WASM_SYMBOL_TYPE_SECTION:
1899
    return SymbolRef::ST_Debug;
1900
  case wasm::WASM_SYMBOL_TYPE_TAG:
1901
    return SymbolRef::ST_Other;
1902
  case wasm::WASM_SYMBOL_TYPE_TABLE:
1903
    return SymbolRef::ST_Other;
1904
  }
1905

1906
  llvm_unreachable("unknown WasmSymbol::SymbolType");
1907
  return SymbolRef::ST_Other;
1908
}
1909

1910
Expected<section_iterator>
1911
WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
1912
  const WasmSymbol &Sym = getWasmSymbol(Symb);
1913
  if (Sym.isUndefined())
1914
    return section_end();
1915

1916
  DataRefImpl Ref;
1917
  Ref.d.a = getSymbolSectionIdImpl(Sym);
1918
  return section_iterator(SectionRef(Ref, this));
1919
}
1920

1921
uint32_t WasmObjectFile::getSymbolSectionId(SymbolRef Symb) const {
1922
  const WasmSymbol &Sym = getWasmSymbol(Symb);
1923
  return getSymbolSectionIdImpl(Sym);
1924
}
1925

1926
uint32_t WasmObjectFile::getSymbolSectionIdImpl(const WasmSymbol &Sym) const {
1927
  switch (Sym.Info.Kind) {
1928
  case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1929
    return CodeSection;
1930
  case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1931
    return GlobalSection;
1932
  case wasm::WASM_SYMBOL_TYPE_DATA:
1933
    return DataSection;
1934
  case wasm::WASM_SYMBOL_TYPE_SECTION:
1935
    return Sym.Info.ElementIndex;
1936
  case wasm::WASM_SYMBOL_TYPE_TAG:
1937
    return TagSection;
1938
  case wasm::WASM_SYMBOL_TYPE_TABLE:
1939
    return TableSection;
1940
  default:
1941
    llvm_unreachable("unknown WasmSymbol::SymbolType");
1942
  }
1943
}
1944

1945
uint32_t WasmObjectFile::getSymbolSize(SymbolRef Symb) const {
1946
  const WasmSymbol &Sym = getWasmSymbol(Symb);
1947
  if (!Sym.isDefined())
1948
    return 0;
1949
  if (Sym.isTypeGlobal())
1950
    return getDefinedGlobal(Sym.Info.ElementIndex).Size;
1951
  if (Sym.isTypeData())
1952
    return Sym.Info.DataRef.Size;
1953
  if (Sym.isTypeFunction())
1954
    return functions()[Sym.Info.ElementIndex - getNumImportedFunctions()].Size;
1955
  // Currently symbol size is only tracked for data segments and functions. In
1956
  // principle we could also track size (e.g. binary size) for tables, globals
1957
  // and element segments etc too.
1958
  return 0;
1959
}
1960

1961
void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
1962

1963
Expected<StringRef> WasmObjectFile::getSectionName(DataRefImpl Sec) const {
1964
  const WasmSection &S = Sections[Sec.d.a];
1965
  if (S.Type == wasm::WASM_SEC_CUSTOM)
1966
    return S.Name;
1967
  if (S.Type > wasm::WASM_SEC_LAST_KNOWN)
1968
    return createStringError(object_error::invalid_section_index, "");
1969
  return wasm::sectionTypeToString(S.Type);
1970
}
1971

1972
uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const {
1973
  // For object files, use 0 for section addresses, and section offsets for
1974
  // symbol addresses. For linked files, use file offsets.
1975
  // See also getSymbolAddress.
1976
  return isRelocatableObject() || isSharedObject() ? 0
1977
                                                   : Sections[Sec.d.a].Offset;
1978
}
1979

1980
uint64_t WasmObjectFile::getSectionIndex(DataRefImpl Sec) const {
1981
  return Sec.d.a;
1982
}
1983

1984
uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
1985
  const WasmSection &S = Sections[Sec.d.a];
1986
  return S.Content.size();
1987
}
1988

1989
Expected<ArrayRef<uint8_t>>
1990
WasmObjectFile::getSectionContents(DataRefImpl Sec) const {
1991
  const WasmSection &S = Sections[Sec.d.a];
1992
  // This will never fail since wasm sections can never be empty (user-sections
1993
  // must have a name and non-user sections each have a defined structure).
1994
  return S.Content;
1995
}
1996

1997
uint64_t WasmObjectFile::getSectionAlignment(DataRefImpl Sec) const {
1998
  return 1;
1999
}
2000

2001
bool WasmObjectFile::isSectionCompressed(DataRefImpl Sec) const {
2002
  return false;
2003
}
2004

2005
bool WasmObjectFile::isSectionText(DataRefImpl Sec) const {
2006
  return getWasmSection(Sec).Type == wasm::WASM_SEC_CODE;
2007
}
2008

2009
bool WasmObjectFile::isSectionData(DataRefImpl Sec) const {
2010
  return getWasmSection(Sec).Type == wasm::WASM_SEC_DATA;
2011
}
2012

2013
bool WasmObjectFile::isSectionBSS(DataRefImpl Sec) const { return false; }
2014

2015
bool WasmObjectFile::isSectionVirtual(DataRefImpl Sec) const { return false; }
2016

2017
relocation_iterator WasmObjectFile::section_rel_begin(DataRefImpl Ref) const {
2018
  DataRefImpl RelocRef;
2019
  RelocRef.d.a = Ref.d.a;
2020
  RelocRef.d.b = 0;
2021
  return relocation_iterator(RelocationRef(RelocRef, this));
2022
}
2023

2024
relocation_iterator WasmObjectFile::section_rel_end(DataRefImpl Ref) const {
2025
  const WasmSection &Sec = getWasmSection(Ref);
2026
  DataRefImpl RelocRef;
2027
  RelocRef.d.a = Ref.d.a;
2028
  RelocRef.d.b = Sec.Relocations.size();
2029
  return relocation_iterator(RelocationRef(RelocRef, this));
2030
}
2031

2032
void WasmObjectFile::moveRelocationNext(DataRefImpl &Rel) const { Rel.d.b++; }
2033

2034
uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Ref) const {
2035
  const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
2036
  return Rel.Offset;
2037
}
2038

2039
symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Ref) const {
2040
  const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
2041
  if (Rel.Type == wasm::R_WASM_TYPE_INDEX_LEB)
2042
    return symbol_end();
2043
  DataRefImpl Sym;
2044
  Sym.d.a = 1;
2045
  Sym.d.b = Rel.Index;
2046
  return symbol_iterator(SymbolRef(Sym, this));
2047
}
2048

2049
uint64_t WasmObjectFile::getRelocationType(DataRefImpl Ref) const {
2050
  const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
2051
  return Rel.Type;
2052
}
2053

2054
void WasmObjectFile::getRelocationTypeName(
2055
    DataRefImpl Ref, SmallVectorImpl<char> &Result) const {
2056
  const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
2057
  StringRef Res = "Unknown";
2058

2059
#define WASM_RELOC(name, value)                                                \
2060
  case wasm::name:                                                             \
2061
    Res = #name;                                                               \
2062
    break;
2063

2064
  switch (Rel.Type) {
2065
#include "llvm/BinaryFormat/WasmRelocs.def"
2066
  }
2067

2068
#undef WASM_RELOC
2069

2070
  Result.append(Res.begin(), Res.end());
2071
}
2072

2073
section_iterator WasmObjectFile::section_begin() const {
2074
  DataRefImpl Ref;
2075
  Ref.d.a = 0;
2076
  return section_iterator(SectionRef(Ref, this));
2077
}
2078

2079
section_iterator WasmObjectFile::section_end() const {
2080
  DataRefImpl Ref;
2081
  Ref.d.a = Sections.size();
2082
  return section_iterator(SectionRef(Ref, this));
2083
}
2084

2085
uint8_t WasmObjectFile::getBytesInAddress() const {
2086
  return HasMemory64 ? 8 : 4;
2087
}
2088

2089
StringRef WasmObjectFile::getFileFormatName() const { return "WASM"; }
2090

2091
Triple::ArchType WasmObjectFile::getArch() const {
2092
  return HasMemory64 ? Triple::wasm64 : Triple::wasm32;
2093
}
2094

2095
Expected<SubtargetFeatures> WasmObjectFile::getFeatures() const {
2096
  return SubtargetFeatures();
2097
}
2098

2099
bool WasmObjectFile::isRelocatableObject() const { return HasLinkingSection; }
2100

2101
bool WasmObjectFile::isSharedObject() const { return HasDylinkSection; }
2102

2103
const WasmSection &WasmObjectFile::getWasmSection(DataRefImpl Ref) const {
2104
  assert(Ref.d.a < Sections.size());
2105
  return Sections[Ref.d.a];
2106
}
2107

2108
const WasmSection &
2109
WasmObjectFile::getWasmSection(const SectionRef &Section) const {
2110
  return getWasmSection(Section.getRawDataRefImpl());
2111
}
2112

2113
const wasm::WasmRelocation &
2114
WasmObjectFile::getWasmRelocation(const RelocationRef &Ref) const {
2115
  return getWasmRelocation(Ref.getRawDataRefImpl());
2116
}
2117

2118
const wasm::WasmRelocation &
2119
WasmObjectFile::getWasmRelocation(DataRefImpl Ref) const {
2120
  assert(Ref.d.a < Sections.size());
2121
  const WasmSection &Sec = Sections[Ref.d.a];
2122
  assert(Ref.d.b < Sec.Relocations.size());
2123
  return Sec.Relocations[Ref.d.b];
2124
}
2125

2126
int WasmSectionOrderChecker::getSectionOrder(unsigned ID,
2127
                                             StringRef CustomSectionName) {
2128
  switch (ID) {
2129
  case wasm::WASM_SEC_CUSTOM:
2130
    return StringSwitch<unsigned>(CustomSectionName)
2131
        .Case("dylink", WASM_SEC_ORDER_DYLINK)
2132
        .Case("dylink.0", WASM_SEC_ORDER_DYLINK)
2133
        .Case("linking", WASM_SEC_ORDER_LINKING)
2134
        .StartsWith("reloc.", WASM_SEC_ORDER_RELOC)
2135
        .Case("name", WASM_SEC_ORDER_NAME)
2136
        .Case("producers", WASM_SEC_ORDER_PRODUCERS)
2137
        .Case("target_features", WASM_SEC_ORDER_TARGET_FEATURES)
2138
        .Default(WASM_SEC_ORDER_NONE);
2139
  case wasm::WASM_SEC_TYPE:
2140
    return WASM_SEC_ORDER_TYPE;
2141
  case wasm::WASM_SEC_IMPORT:
2142
    return WASM_SEC_ORDER_IMPORT;
2143
  case wasm::WASM_SEC_FUNCTION:
2144
    return WASM_SEC_ORDER_FUNCTION;
2145
  case wasm::WASM_SEC_TABLE:
2146
    return WASM_SEC_ORDER_TABLE;
2147
  case wasm::WASM_SEC_MEMORY:
2148
    return WASM_SEC_ORDER_MEMORY;
2149
  case wasm::WASM_SEC_GLOBAL:
2150
    return WASM_SEC_ORDER_GLOBAL;
2151
  case wasm::WASM_SEC_EXPORT:
2152
    return WASM_SEC_ORDER_EXPORT;
2153
  case wasm::WASM_SEC_START:
2154
    return WASM_SEC_ORDER_START;
2155
  case wasm::WASM_SEC_ELEM:
2156
    return WASM_SEC_ORDER_ELEM;
2157
  case wasm::WASM_SEC_CODE:
2158
    return WASM_SEC_ORDER_CODE;
2159
  case wasm::WASM_SEC_DATA:
2160
    return WASM_SEC_ORDER_DATA;
2161
  case wasm::WASM_SEC_DATACOUNT:
2162
    return WASM_SEC_ORDER_DATACOUNT;
2163
  case wasm::WASM_SEC_TAG:
2164
    return WASM_SEC_ORDER_TAG;
2165
  default:
2166
    return WASM_SEC_ORDER_NONE;
2167
  }
2168
}
2169

2170
// Represents the edges in a directed graph where any node B reachable from node
2171
// A is not allowed to appear before A in the section ordering, but may appear
2172
// afterward.
2173
int WasmSectionOrderChecker::DisallowedPredecessors
2174
    [WASM_NUM_SEC_ORDERS][WASM_NUM_SEC_ORDERS] = {
2175
        // WASM_SEC_ORDER_NONE
2176
        {},
2177
        // WASM_SEC_ORDER_TYPE
2178
        {WASM_SEC_ORDER_TYPE, WASM_SEC_ORDER_IMPORT},
2179
        // WASM_SEC_ORDER_IMPORT
2180
        {WASM_SEC_ORDER_IMPORT, WASM_SEC_ORDER_FUNCTION},
2181
        // WASM_SEC_ORDER_FUNCTION
2182
        {WASM_SEC_ORDER_FUNCTION, WASM_SEC_ORDER_TABLE},
2183
        // WASM_SEC_ORDER_TABLE
2184
        {WASM_SEC_ORDER_TABLE, WASM_SEC_ORDER_MEMORY},
2185
        // WASM_SEC_ORDER_MEMORY
2186
        {WASM_SEC_ORDER_MEMORY, WASM_SEC_ORDER_TAG},
2187
        // WASM_SEC_ORDER_TAG
2188
        {WASM_SEC_ORDER_TAG, WASM_SEC_ORDER_GLOBAL},
2189
        // WASM_SEC_ORDER_GLOBAL
2190
        {WASM_SEC_ORDER_GLOBAL, WASM_SEC_ORDER_EXPORT},
2191
        // WASM_SEC_ORDER_EXPORT
2192
        {WASM_SEC_ORDER_EXPORT, WASM_SEC_ORDER_START},
2193
        // WASM_SEC_ORDER_START
2194
        {WASM_SEC_ORDER_START, WASM_SEC_ORDER_ELEM},
2195
        // WASM_SEC_ORDER_ELEM
2196
        {WASM_SEC_ORDER_ELEM, WASM_SEC_ORDER_DATACOUNT},
2197
        // WASM_SEC_ORDER_DATACOUNT
2198
        {WASM_SEC_ORDER_DATACOUNT, WASM_SEC_ORDER_CODE},
2199
        // WASM_SEC_ORDER_CODE
2200
        {WASM_SEC_ORDER_CODE, WASM_SEC_ORDER_DATA},
2201
        // WASM_SEC_ORDER_DATA
2202
        {WASM_SEC_ORDER_DATA, WASM_SEC_ORDER_LINKING},
2203

2204
        // Custom Sections
2205
        // WASM_SEC_ORDER_DYLINK
2206
        {WASM_SEC_ORDER_DYLINK, WASM_SEC_ORDER_TYPE},
2207
        // WASM_SEC_ORDER_LINKING
2208
        {WASM_SEC_ORDER_LINKING, WASM_SEC_ORDER_RELOC, WASM_SEC_ORDER_NAME},
2209
        // WASM_SEC_ORDER_RELOC (can be repeated)
2210
        {},
2211
        // WASM_SEC_ORDER_NAME
2212
        {WASM_SEC_ORDER_NAME, WASM_SEC_ORDER_PRODUCERS},
2213
        // WASM_SEC_ORDER_PRODUCERS
2214
        {WASM_SEC_ORDER_PRODUCERS, WASM_SEC_ORDER_TARGET_FEATURES},
2215
        // WASM_SEC_ORDER_TARGET_FEATURES
2216
        {WASM_SEC_ORDER_TARGET_FEATURES}};
2217

2218
bool WasmSectionOrderChecker::isValidSectionOrder(unsigned ID,
2219
                                                  StringRef CustomSectionName) {
2220
  int Order = getSectionOrder(ID, CustomSectionName);
2221
  if (Order == WASM_SEC_ORDER_NONE)
2222
    return true;
2223

2224
  // Disallowed predecessors we need to check for
2225
  SmallVector<int, WASM_NUM_SEC_ORDERS> WorkList;
2226

2227
  // Keep track of completed checks to avoid repeating work
2228
  bool Checked[WASM_NUM_SEC_ORDERS] = {};
2229

2230
  int Curr = Order;
2231
  while (true) {
2232
    // Add new disallowed predecessors to work list
2233
    for (size_t I = 0;; ++I) {
2234
      int Next = DisallowedPredecessors[Curr][I];
2235
      if (Next == WASM_SEC_ORDER_NONE)
2236
        break;
2237
      if (Checked[Next])
2238
        continue;
2239
      WorkList.push_back(Next);
2240
      Checked[Next] = true;
2241
    }
2242

2243
    if (WorkList.empty())
2244
      break;
2245

2246
    // Consider next disallowed predecessor
2247
    Curr = WorkList.pop_back_val();
2248
    if (Seen[Curr])
2249
      return false;
2250
  }
2251

2252
  // Have not seen any disallowed predecessors
2253
  Seen[Order] = true;
2254
  return true;
2255
}
2256