CbC/CbC_llvm: lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp comparison

comparison lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp @ 121:803732b1fca8

LLVM 5.0

author	kono
date	Fri, 27 Oct 2017 17:07:41 +0900
parents	1172e4bd9c6f
children	c2174574ed3a

comparison

equal deleted inserted replaced

-:1172e4bd9c6f
+:803732b1fca8
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#include "MCTargetDesc/X86FixupKinds.h"
 #include "MCTargetDesc/X86MCTargetDesc.h"
-#include "MCTargetDesc/X86FixupKinds.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/BinaryFormat/MachO.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCMachObjectWriter.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
-#include "llvm/Support/MachO.h"
 using namespace llvm;
 namespace {
 class X86MachObjectWriter : public MCMachObjectTargetWriter {
 if (B->isTemporary())
 B = &Writer->findAliasedSymbol(*B);
 const MCSymbol *B_Base = Asm.getAtom(*B);
 // Neither symbol can be modified.
-if (Target.getSymA()->getKind() != MCSymbolRefExpr::VK_None ||
+if (Target.getSymA()->getKind() != MCSymbolRefExpr::VK_None) {
-Target.getSymB()->getKind() != MCSymbolRefExpr::VK_None) {
 Asm.getContext().reportError(Fixup.getLoc(),
 "unsupported relocation of modified symbol");
 return;
 }
 const MCSymbol *SB = &B->getSymbol();
 if (!SB->getFragment()) {
 Asm.getContext().reportError(
 Fixup.getLoc(),
-"symbol '" + B->getSymbol().getName() +
+"symbol '" + SB->getName() +
 "' can not be undefined in a subtraction expression");
 return false;
 }
 // Select the appropriate difference relocation type.
 // Note that there is no longer any semantic difference between these two
 // relocation types from the linkers point of view, this is done solely for
 // pedantic compatibility with 'as'.
 Type = A->isExternal() ? (unsigned)MachO::GENERIC_RELOC_SECTDIFF
 : (unsigned)MachO::GENERIC_RELOC_LOCAL_SECTDIFF;
-Value2 = Writer->getSymbolAddress(B->getSymbol(), Layout);
+Value2 = Writer->getSymbolAddress(*SB, Layout);
 FixedValue -= Writer->getSectionAddress(SB->getFragment()->getParent());
 }
 // Relocations are written out in reverse order, so the PAIR comes first.
 if (Type == MachO::GENERIC_RELOC_SECTDIFF ||
 const MCAsmLayout &Layout,
 const MCFragment *Fragment,
 const MCFixup &Fixup,
 MCValue Target,
 uint64_t &FixedValue) {
-assert(Target.getSymA()->getKind() == MCSymbolRefExpr::VK_TLVP &&
+const MCSymbolRefExpr *SymA = Target.getSymA();
-!is64Bit() &&
+assert(SymA->getKind() == MCSymbolRefExpr::VK_TLVP && !is64Bit() &&
 "Should only be called with a 32-bit TLVP relocation!");
 unsigned Log2Size = getFixupKindLog2Size(Fixup.getKind());
 uint32_t Value = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
 unsigned IsPCRel = 0;
 // We're only going to have a second symbol in pic mode and it'll be a
 // subtraction from the picbase. For 32-bit pic the addend is the difference
 // between the picbase and the next address.  For 32-bit static the addend is
 // zero.
-if (Target.getSymB()) {
+if (auto *SymB = Target.getSymB()) {
 // If this is a subtraction then we're pcrel.
 uint32_t FixupAddress =
 Writer->getFragmentAddress(Fragment, Layout) + Fixup.getOffset();
 IsPCRel = 1;
-FixedValue =
+FixedValue = FixupAddress -
-FixupAddress -
+Writer->getSymbolAddress(SymB->getSymbol(), Layout) +
-Writer->getSymbolAddress(Target.getSymB()->getSymbol(), Layout) +
+Target.getConstant();
-Target.getConstant();
 FixedValue += 1ULL << Log2Size;
 } else {
 FixedValue = 0;
 }
 // struct relocation_info (8 bytes)
 MachO::any_relocation_info MRE;
 MRE.r_word0 = Value;
 MRE.r_word1 =
 (IsPCRel << 24) | (Log2Size << 25) | (MachO::GENERIC_RELOC_TLV << 28);
-Writer->addRelocation(&Target.getSymA()->getSymbol(), Fragment->getParent(),
+Writer->addRelocation(&SymA->getSymbol(), Fragment->getParent(), MRE);
-MRE);
 }
 void X86MachObjectWriter::RecordX86Relocation(MachObjectWriter *Writer,
 const MCAssembler &Asm,
 const MCAsmLayout &Layout,
 MRE.r_word1 =
 (Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | (Type << 28);
 Writer->addRelocation(RelSymbol, Fragment->getParent(), MRE);
 }
-MCObjectWriter *llvm::createX86MachObjectWriter(raw_pwrite_stream &OS,
+std::unique_ptr<MCObjectWriter>
-bool Is64Bit, uint32_t CPUType,
+llvm::createX86MachObjectWriter(raw_pwrite_stream &OS, bool Is64Bit,
-uint32_t CPUSubtype) {
+uint32_t CPUType, uint32_t CPUSubtype) {
-return createMachObjectWriter(new X86MachObjectWriter(Is64Bit,
+return createMachObjectWriter(
-CPUType,
+llvm::make_unique<X86MachObjectWriter>(Is64Bit, CPUType, CPUSubtype), OS,
-CPUSubtype),
+/*IsLittleEndian=*/true);
-OS, /*IsLittleEndian=*/true);
+}
-}

Mercurial > hg > CbC > CbC_llvm

comparison lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp @ 121:803732b1fca8