Suzero. X8664. NaCl Sandboxing.

src/IceELFObjectWriter.cpp

 //===- subzero/src/IceELFObjectWriter.cpp - ELF object file writer --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 12 matching lines @@
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace llvm::ELF;
 
 namespace Ice {
 
 namespace {
 
-struct {
+constexpr struct {
   bool IsELF64;
   uint16_t ELFMachine;
   uint32_t ELFFlags;
-} ELFTargetInfo[] = {
+} ELFTargetInfo[TargetArch_NUM] = {
 #define X(tag, str, is_elf64, e_machine, e_flags)                              \
   { is_elf64, e_machine, e_flags }                                             \
   ,
     TARGETARCH_TABLE
 #undef X
 };
 
-bool isELF64(TargetArch Arch) {
-  if (Arch < TargetArch_NUM)
-    return ELFTargetInfo[Arch].IsELF64;
-  llvm_unreachable("Invalid target arch for isELF64");
-  return false;
+bool isELF64(const ClFlags &Flags) {
+  const TargetArch Arch = Flags.getTargetArch();
+  if (Arch >= TargetArch_NUM) {
+    llvm_unreachable("Invalid target arch for isELF64");
+    return false;
+  }
+
+  if (!Flags.getUseSandboxing()) {
+    // Unsandboxed code is always ELF32 (pexes are ILP32.)
+    return false;
+  }
+
+  return ELFTargetInfo[Arch].IsELF64;
 }
 
 uint16_t getELFMachine(TargetArch Arch) {
   if (Arch < TargetArch_NUM)
     return ELFTargetInfo[Arch].ELFMachine;
   llvm_unreachable("Invalid target arch for getELFMachine");
   return EM_NONE;
 }
 
 uint32_t getELFFlags(TargetArch Arch) {
   if (Arch < TargetArch_NUM)
     return ELFTargetInfo[Arch].ELFFlags;
   llvm_unreachable("Invalid target arch for getELFFlags");
   return 0;
 }
 
 } // end of anonymous namespace
 
 ELFObjectWriter::ELFObjectWriter(GlobalContext &Ctx, ELFStreamer &Out)
-    : Ctx(Ctx), Str(Out), ELF64(isELF64(Ctx.getFlags().getTargetArch())) {
+    : Ctx(Ctx), Str(Out), ELF64(isELF64(Ctx.getFlags())) {
   // Create the special bookkeeping sections now.
   const IceString NullSectionName("");
   NullSection = new (Ctx.allocate<ELFSection>())
       ELFSection(NullSectionName, SHT_NULL, 0, 0, 0);
 
   const IceString ShStrTabName(".shstrtab");
   ShStrTab = new (Ctx.allocate<ELFStringTableSection>())
       ELFStringTableSection(ShStrTabName, SHT_STRTAB, 0, 1, 0);
   ShStrTab->add(ShStrTabName);
 
@@ skipping 144 matching lines @@
                                             ShAlign, 0);
     Elf64_Off OffsetInFile = alignFileOffset(Section->getSectionAlign());
     Section->setFileOffset(OffsetInFile);
     TextSections.push_back(Section);
     RelSection = createRelocationSection(Section);
     RelTextSections.push_back(RelSection);
   } else {
     Section = TextSections[0];
     RelSection = RelTextSections[0];
   }
-  RelocOffsetT OffsetInSection = Section->getCurrentSize();
+  const RelocOffsetT OffsetInSection = Section->getCurrentSize();
   // Function symbols are set to 0 size in the symbol table, in contrast to
   // data symbols which have a proper size.
-  SizeT SymbolSize = 0;
+  constexpr SizeT SymbolSize = 0;
   Section->appendData(Str, Asm->getBufferView());
   uint8_t SymbolType;
   uint8_t SymbolBinding;
   if (IsInternal && !Ctx.getFlags().getDisableInternal()) {
     SymbolType = STT_NOTYPE;
     SymbolBinding = STB_LOCAL;
   } else {
     SymbolType = STT_FUNC;
     SymbolBinding = STB_GLOBAL;
   }
   SymTab->createDefinedSym(FuncName, SymbolType, SymbolBinding, Section,
                            OffsetInSection, SymbolSize);
   StrTab->add(FuncName);
+  for (const auto &InternalReloc : Asm->getInternalRelocations()) {
+    const IceString &RelocName = InternalReloc.first;
+    constexpr uint8_t RelocSymbolType = STT_NOTYPE;
+    constexpr uint8_t RelocSymbolBinding = STB_LOCAL;
+    const SizeT RelocOffsetInSection = OffsetInSection + InternalReloc.second;
+    SymTab->createDefinedSym(RelocName, RelocSymbolType, RelocSymbolBinding,
+                             Section, RelocOffsetInSection, SymbolSize);
+    StrTab->add(RelocName);
+  }
 
   // Copy the fixup information from per-function Assembler memory to the
   // object writer's memory, for writing later.
   if (!Asm->fixups().empty()) {
     RelSection->addRelocations(OffsetInSection, Asm->fixups());
   }
 }
 
 namespace {
 
@@ skipping 411 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice