Subzero: Start writing out some relocation sections (text)

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 "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 Constant *Sym) {
-    return new (Asm->Allocate<DirectCallRelocation>())
-        DirectCallRelocation(Kind, Sym);
-  }
-
-private:
-  DirectCallRelocation(FixupKind Kind, const Constant *Sym)
-      : AssemblerFixup(Kind, Sym) {}
-};
-
 Address Address::ofConstPool(Assembler *Asm, const Constant *Imm) {
-  AssemblerFixup *Fixup =
-      x86::DisplacementRelocation::create(Asm, FK_Abs_4, Imm);
+  AssemblerFixup *Fixup = Asm->createFixup(llvm::ELF::R_386_32, Imm);
   const RelocOffsetT Offset = 0;
   return x86::Address::Absolute(Offset, Fixup);
 }
 
 AssemblerX86::~AssemblerX86() {
 #ifndef NDEBUG
   for (const Label *Label : CfgNodeLabels) {
     Label->FinalCheck();
   }
   for (const Label *Label : LocalLabels) {
@@ skipping 63 matching lines @@
 void AssemblerX86::call(const Address &address) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xFF);
   EmitOperand(2, address);
 }
 
 void AssemblerX86::call(const ConstantRelocatable *label) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   intptr_t call_start = buffer_.GetPosition();
   EmitUint8(0xE8);
-  EmitFixup(DirectCallRelocation::create(this, FK_PcRel_4, label));
+  EmitFixup(this->createFixup(llvm::ELF::R_386_PC32, label));
   EmitInt32(-4);
   assert((buffer_.GetPosition() - call_start) == kCallExternalLabelSize);
   (void)call_start;
 }
 
 void AssemblerX86::pushl(GPRRegister reg) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0x50 + reg);
 }
 
@@ skipping 2126 matching lines @@
     EmitUint8(0x80 + condition);
     EmitLabelLink(label);
   }
 }
 
 void AssemblerX86::j(CondX86::BrCond condition,
                      const ConstantRelocatable *label) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0x0F);
   EmitUint8(0x80 + condition);
-  EmitFixup(DirectCallRelocation::create(this, FK_PcRel_4, label));
+  EmitFixup(this->createFixup(llvm::ELF::R_386_PC32, label));
   EmitInt32(-4);
 }
 
 void AssemblerX86::jmp(GPRRegister reg) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xFF);
   EmitRegisterOperand(4, reg);
 }
 
 void AssemblerX86::jmp(Label *label, bool near) {
@@ skipping 15 matching lines @@
     EmitNearLabelLink(label);
   } else {
     EmitUint8(0xE9);
     EmitLabelLink(label);
   }
 }
 
 void AssemblerX86::jmp(const ConstantRelocatable *label) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xE9);
-  EmitFixup(DirectCallRelocation::create(this, FK_PcRel_4, label));
+  EmitFixup(this->createFixup(llvm::ELF::R_386_PC32, label));
   EmitInt32(-4);
 }
 
 void AssemblerX86::mfence() {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0x0F);
   EmitUint8(0xAE);
   EmitUint8(0xF0);
 }
 
@@ skipping 194 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