Subzero: Add basic ELFObjectWriter (text section, symtab, strtab, headers)

src/assembler_ia32.cpp

 //===- subzero/src/assembler_ia32.cpp - Assembler for x86-32  -------------===//
 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Assembler class for x86-32.
 //
 //===----------------------------------------------------------------------===//
 
 #include "assembler_ia32.h"
 #include "IceCfg.h"
-#include "IceMemoryRegion.h"
 #include "IceOperand.h"
 
 namespace Ice {
 namespace x86 {
 
 class DirectCallRelocation : public AssemblerFixup {
   DirectCallRelocation(const DirectCallRelocation &) = delete;
   DirectCallRelocation &operator=(const DirectCallRelocation &) = delete;
 
 public:
   static DirectCallRelocation *create(Assembler *Asm, FixupKind Kind,
                                       const ConstantRelocatable *Sym) {
     return new (Asm->Allocate<DirectCallRelocation>())
         DirectCallRelocation(Kind, Sym);
   }
 
-  void Process(const MemoryRegion &region, intptr_t position) override {
-    // Direct calls are relative to the following instruction on x86.
-    int32_t pointer = region.Load<int32_t>(position);
-    int32_t delta = region.start() + position + sizeof(int32_t);
-    region.Store<int32_t>(position, pointer - delta);
-  }
-
 private:
   DirectCallRelocation(FixupKind Kind, const ConstantRelocatable *Sym)
       : AssemblerFixup(Kind, Sym) {}
 };
 
 Address Address::ofConstPool(GlobalContext *Ctx, Assembler *Asm,
                              const Constant *Imm) {
   // We should make this much lighter-weight. E.g., just record the const pool
   // entry ID.
   std::string Buffer;
@@ skipping 14 matching lines @@
 #ifndef NDEBUG
   for (const Label *Label : CfgNodeLabels) {
     Label->FinalCheck();
   }
   for (const Label *Label : LocalLabels) {
     Label->FinalCheck();
   }
 #endif
 }
 
+void AssemblerX86::alignFunction() {
+  intptr_t Pos = buffer_.GetPosition();
+  SizeT Align = 1 << getBundleAlignLog2Bytes();
+  intptr_t Mod = Pos & (Align - 1);
+  if (Mod == 0) {
+    return;
+  }
+  SizeT BytesNeeded = Align - Mod;
+  const SizeT HltSize = 1;
+  while (BytesNeeded > 0) {
+    hlt();
+    BytesNeeded -= HltSize;
+  }
+  assert((buffer_.GetPosition() & (Align - 1)) == 0);
+}
+
 Label *AssemblerX86::GetOrCreateLabel(SizeT Number, LabelVector &Labels) {
   Label *L = nullptr;
   if (Number == Labels.size()) {
     L = new (this->Allocate<Label>()) Label();
     Labels.push_back(L);
     return L;
   }
   if (Number > Labels.size()) {
     Labels.resize(Number + 1);
   }
@@ skipping 2430 matching lines @@
   assert(shifter == RegX8632::Encoded_Reg_ecx);
   (void)shifter;
   if (Ty == IceType_i16)
     EmitOperandSizeOverride();
   EmitUint8(isByteSizedArithType(Ty) ? 0xD2 : 0xD3);
   EmitOperand(rm, operand);
 }
 
 } // end of namespace x86
 } // end of namespace Ice