class MCStreamer;
class DwarfWriter;
class Mangler;
- class TargetAsmInfo;
+ class MCAsmInfo;
class TargetLoweringObjectFile;
class Type;
class formatted_raw_ostream;
/// Target Asm Printer information.
///
- const TargetAsmInfo *TAI;
+ const MCAsmInfo *TAI;
/// Target Register Information.
///
protected:
explicit AsmPrinter(formatted_raw_ostream &o, TargetMachine &TM,
- const TargetAsmInfo *T, bool V);
+ const MCAsmInfo *T, bool V);
public:
virtual ~AsmPrinter();
class Value;
class Module;
class GlobalVariable;
-class TargetAsmInfo;
+class MCAsmInfo;
class raw_ostream;
class Instruction;
class DICompileUnit;
/// BeginModule - Emit all Dwarf sections that should come prior to the
/// content.
void BeginModule(Module *M, MachineModuleInfo *MMI, raw_ostream &OS,
- AsmPrinter *A, const TargetAsmInfo *T);
+ AsmPrinter *A, const MCAsmInfo *T);
/// EndModule - Emit all Dwarf sections that should come after the content.
///
class AsmPrinter;
class GCStrategy;
class Constant;
- class TargetAsmInfo;
+ class MCAsmInfo;
namespace GC {
/// beginAssembly/finishAssembly - Emit module metadata as assembly code.
virtual void beginAssembly(raw_ostream &OS, AsmPrinter &AP,
- const TargetAsmInfo &TAI);
+ const MCAsmInfo &TAI);
virtual void finishAssembly(raw_ostream &OS, AsmPrinter &AP,
- const TargetAsmInfo &TAI);
+ const MCAsmInfo &TAI);
virtual ~GCMetadataPrinter();
};
--- /dev/null
+
+#include "llvm/Target/TargetAsmInfo.h"
+
--- /dev/null
+#include "llvm/Target/COFFTargetAsmInfo.h"
+
--- /dev/null
+#include "llvm/Target/DarwinTargetAsmInfo.h"
namespace llvm {
class MCContext;
- class TargetAsmInfo;
+ class MCAsmInfo;
class raw_ostream;
/// MCSection - Instances of this class represent a uniqued identifier for a
SectionKind getKind() const { return Kind; }
- virtual void PrintSwitchToSection(const TargetAsmInfo &TAI,
+ virtual void PrintSwitchToSection(const MCAsmInfo &TAI,
raw_ostream &OS) const = 0;
};
const std::string &getName() const { return Name; }
bool isDirective() const { return IsDirective; }
- virtual void PrintSwitchToSection(const TargetAsmInfo &TAI,
+ virtual void PrintSwitchToSection(const MCAsmInfo &TAI,
raw_ostream &OS) const;
};
/// ShouldOmitSectionDirective - Decides whether a '.section' directive
/// should be printed before the section name
bool ShouldOmitSectionDirective(const char *Name,
- const TargetAsmInfo &TAI) const;
+ const MCAsmInfo &TAI) const;
/// ShouldPrintSectionType - Only prints the section type if supported
bool ShouldPrintSectionType(unsigned Ty) const;
unsigned getType() const { return Type; }
unsigned getFlags() const { return Flags; }
- virtual void PrintSwitchToSection(const TargetAsmInfo &TAI,
+ virtual void PrintSwitchToSection(const MCAsmInfo &TAI,
raw_ostream &OS) const;
/// MCSectionELF subclasses with target specific section flags should
/// implement this method if they end up adding letters to the attributes
/// list.
- virtual void PrintTargetSpecificSectionFlags(const TargetAsmInfo &TAI,
+ virtual void PrintTargetSpecificSectionFlags(const MCAsmInfo &TAI,
raw_ostream &OS) const {
}
unsigned &TAA, // Out.
unsigned &StubSize); // Out.
- virtual void PrintSwitchToSection(const TargetAsmInfo &TAI,
+ virtual void PrintSwitchToSection(const MCAsmInfo &TAI,
raw_ostream &OS) const;
};
class MCSymbol;
class StringRef;
class raw_ostream;
- class TargetAsmInfo;
+ class MCAsmInfo;
/// MCStreamer - Streaming machine code generation interface. This interface
/// is intended to provide a programatic interface that is very similar to the
///
/// \arg AP - If given, an AsmPrinter to use for printing instructions.
MCStreamer *createAsmStreamer(MCContext &Ctx, raw_ostream &OS,
- const TargetAsmInfo &TAI, AsmPrinter *AP = 0);
+ const MCAsmInfo &TAI, AsmPrinter *AP = 0);
// FIXME: These two may end up getting rolled into a single
// createObjectStreamer interface, which implements the assembler backend, and
-//===-- COFFTargetAsmInfo.h - COFF asm properties ---------------*- C++ -*-===//
+//===-- MCAsmInfoCOFF.h - COFF asm properties -------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
#ifndef LLVM_COFF_TARGET_ASM_INFO_H
#define LLVM_COFF_TARGET_ASM_INFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
- class COFFTargetAsmInfo : public TargetAsmInfo {
+ class COFFMCAsmInfo : public MCAsmInfo {
protected:
- explicit COFFTargetAsmInfo();
+ explicit COFFMCAsmInfo();
};
}
-//===---- DarwinTargetAsmInfo.h - Darwin asm properties ---------*- C++ -*-===//
+//===---- DarwinMCAsmInfo.h - Darwin asm properties -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
#ifndef LLVM_DARWIN_TARGET_ASM_INFO_H
#define LLVM_DARWIN_TARGET_ASM_INFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class GlobalValue;
class Type;
class Mangler;
- struct DarwinTargetAsmInfo : public TargetAsmInfo {
- explicit DarwinTargetAsmInfo();
+ struct DarwinMCAsmInfo : public MCAsmInfo {
+ explicit DarwinMCAsmInfo();
};
}
-//===-- llvm/Target/TargetAsmInfo.h - Asm info ------------------*- C++ -*-===//
+//===-- llvm/MC/MCAsmInfo.h - Asm info --------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
namespace llvm {
template <typename T> class SmallVectorImpl;
- /// TargetAsmInfo - This class is intended to be used as a base class for asm
+ /// MCAsmInfo - This class is intended to be used as a base class for asm
/// properties and features specific to the target.
namespace ExceptionHandling { enum ExceptionsType { None, Dwarf, SjLj }; }
- class TargetAsmInfo {
+ class MCAsmInfo {
protected:
//===------------------------------------------------------------------===//
// Properties to be set by the target writer, used to configure asm printer.
const char *const *AsmTransCBE; // Defaults to empty
public:
- explicit TargetAsmInfo();
- virtual ~TargetAsmInfo();
+ explicit MCAsmInfo();
+ virtual ~MCAsmInfo();
/// getSLEB128Size - Compute the number of bytes required for a signed
/// leb128 value.
namespace llvm {
-class TargetAsmInfo;
+class MCAsmInfo;
class TargetRegisterClass;
class TargetRegisterInfo;
class LiveVariables;
/// Measure the specified inline asm to determine an approximation of its
/// length.
virtual unsigned getInlineAsmLength(const char *Str,
- const TargetAsmInfo &TAI) const;
+ const MCAsmInfo &TAI) const;
};
/// TargetInstrInfoImpl - This is the default implementation of
class GlobalValue;
class StringRef;
class TargetMachine;
- class TargetAsmInfo;
+ class MCAsmInfo;
class TargetLoweringObjectFile {
MCContext *Ctx;
namespace llvm {
class Target;
-class TargetAsmInfo;
+class MCAsmInfo;
class TargetData;
class TargetSubtarget;
class TargetInstrInfo;
/// AsmInfo - Contains target specific asm information.
///
- const TargetAsmInfo *AsmInfo;
+ const MCAsmInfo *AsmInfo;
public:
virtual ~TargetMachine();
virtual TargetLowering *getTargetLowering() const { return 0; }
virtual const TargetData *getTargetData() const { return 0; }
- /// getTargetAsmInfo - Return target specific asm information.
+ /// getMCAsmInfo - Return target specific asm information.
///
- const TargetAsmInfo *getTargetAsmInfo() const { return AsmInfo; }
+ const MCAsmInfo *getMCAsmInfo() const { return AsmInfo; }
/// getSubtarget - This method returns a pointer to the specified type of
/// TargetSubtarget. In debug builds, it verifies that the object being
class AsmPrinter;
class MCAsmParser;
class Module;
- class TargetAsmInfo;
+ class MCAsmInfo;
class TargetAsmParser;
class TargetMachine;
class formatted_raw_ostream;
typedef unsigned (*TripleMatchQualityFnTy)(const std::string &TT);
- typedef const TargetAsmInfo *(*AsmInfoCtorFnTy)(const Target &T,
- const StringRef &TT);
+ typedef const MCAsmInfo *(*AsmInfoCtorFnTy)(const Target &T,
+ const StringRef &TT);
typedef TargetMachine *(*TargetMachineCtorTy)(const Target &T,
const std::string &TT,
const std::string &Features);
typedef AsmPrinter *(*AsmPrinterCtorTy)(formatted_raw_ostream &OS,
TargetMachine &TM,
- const TargetAsmInfo *TAI,
+ const MCAsmInfo *TAI,
bool VerboseAsm);
typedef TargetAsmParser *(*AsmParserCtorTy)(const Target &T,
MCAsmParser &P);
bool hasAsmParser() const { return AsmParserCtorFn != 0; }
- /// createAsmInfo - Create a TargetAsmInfo implementation for the specified
+ /// createAsmInfo - Create a MCAsmInfo implementation for the specified
/// target triple.
///
/// \arg Triple - This argument is used to determine the target machine
/// feature set; it should always be provided. Generally this should be
/// either the target triple from the module, or the target triple of the
/// host if that does not exist.
- const TargetAsmInfo *createAsmInfo(const StringRef &Triple) const {
+ const MCAsmInfo *createAsmInfo(const StringRef &Triple) const {
if (!AsmInfoCtorFn)
return 0;
return AsmInfoCtorFn(*this, Triple);
/// createAsmPrinter - Create a target specific assembly printer pass.
AsmPrinter *createAsmPrinter(formatted_raw_ostream &OS, TargetMachine &TM,
- const TargetAsmInfo *TAI, bool Verbose) const {
+ const MCAsmInfo *TAI, bool Verbose) const {
if (!AsmPrinterCtorFn)
return 0;
return AsmPrinterCtorFn(OS, TM, TAI, Verbose);
Target::TripleMatchQualityFnTy TQualityFn,
bool HasJIT = false);
- /// RegisterAsmInfo - Register a TargetAsmInfo implementation for the
+ /// RegisterAsmInfo - Register a MCAsmInfo implementation for the
/// given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
- /// @param Fn - A function to construct a TargetAsmInfo for the target.
+ /// @param Fn - A function to construct a MCAsmInfo for the target.
static void RegisterAsmInfo(Target &T, Target::AsmInfoCtorFnTy Fn) {
// Ignore duplicate registration.
if (!T.AsmInfoCtorFn)
///
/// extern "C" void LLVMInitializeFooTarget() {
/// extern Target TheFooTarget;
- /// RegisterAsmInfo<FooTargetAsmInfo> X(TheFooTarget);
+ /// RegisterAsmInfo<FooMCAsmInfo> X(TheFooTarget);
/// }
- template<class TargetAsmInfoImpl>
+ template<class MCAsmInfoImpl>
struct RegisterAsmInfo {
RegisterAsmInfo(Target &T) {
TargetRegistry::RegisterAsmInfo(T, &Allocator);
}
private:
- static const TargetAsmInfo *Allocator(const Target &T, const StringRef &TT){
- return new TargetAsmInfoImpl(T, TT);
+ static const MCAsmInfo *Allocator(const Target &T, const StringRef &TT) {
+ return new MCAsmInfoImpl(T, TT);
}
};
private:
static AsmPrinter *Allocator(formatted_raw_ostream &OS, TargetMachine &TM,
- const TargetAsmInfo *TAI, bool Verbose) {
+ const MCAsmInfo *TAI, bool Verbose) {
return new AsmPrinterImpl(OS, TM, TAI, Verbose);
}
};
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Support/Mangler.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLowering.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
char AsmPrinter::ID = 0;
AsmPrinter::AsmPrinter(formatted_raw_ostream &o, TargetMachine &tm,
- const TargetAsmInfo *T, bool VDef)
+ const MCAsmInfo *T, bool VDef)
: MachineFunctionPass(&ID), FunctionNumber(0), O(o),
TM(tm), TAI(T), TRI(tm.getRegisterInfo()),
///
static void PrintChildLoopComment(formatted_raw_ostream &O,
const MachineLoop *loop,
- const TargetAsmInfo *TAI,
+ const MCAsmInfo *TAI,
int FunctionNumber) {
// Add child loop information
for(MachineLoop::iterator cl = loop->begin(),
#include "DIE.h"
#include "DwarfPrinter.h"
#include "llvm/CodeGen/AsmPrinter.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Support/ErrorHandling.h"
#include <ostream>
case dwarf::DW_FORM_data4: return sizeof(int32_t);
case dwarf::DW_FORM_ref8: // Fall thru
case dwarf::DW_FORM_data8: return sizeof(int64_t);
- case dwarf::DW_FORM_udata: return TargetAsmInfo::getULEB128Size(Integer);
- case dwarf::DW_FORM_sdata: return TargetAsmInfo::getSLEB128Size(Integer);
+ case dwarf::DW_FORM_udata: return MCAsmInfo::getULEB128Size(Integer);
+ case dwarf::DW_FORM_sdata: return MCAsmInfo::getSLEB128Size(Integer);
default: llvm_unreachable("DIE Value form not supported yet"); break;
}
return 0;
case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
- case dwarf::DW_FORM_block: return Size + TargetAsmInfo::getULEB128Size(Size);
+ case dwarf::DW_FORM_block: return Size + MCAsmInfo::getULEB128Size(Size);
default: llvm_unreachable("Improper form for block"); break;
}
return 0;
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/MC/MCSection.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetFrameInfo.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
} // end llvm namespace
-DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
+DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
: Dwarf(OS, A, T, "dbg"), ModuleCU(0),
AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
ValuesSet(InitValuesSetSize), Values(), StringPool(),
Die->setOffset(Offset);
// Start the size with the size of abbreviation code.
- Offset += TargetAsmInfo::getULEB128Size(AbbrevNumber);
+ Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
const SmallVector<DIEValue*, 32> &Values = Die->getValues();
const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
class DbgConcreteScope;
class MachineFrameInfo;
class MachineModuleInfo;
-class TargetAsmInfo;
+class MCAsmInfo;
class Timer;
//===----------------------------------------------------------------------===//
//===--------------------------------------------------------------------===//
// Main entry points.
//
- DwarfDebug(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T);
+ DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T);
virtual ~DwarfDebug();
/// ShouldEmitDwarfDebug - Returns true if Dwarf debugging declarations should
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineLocation.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetFrameInfo.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
}
DwarfException::DwarfException(raw_ostream &OS, AsmPrinter *A,
- const TargetAsmInfo *T)
+ const MCAsmInfo *T)
: Dwarf(OS, A, T, "eh"), shouldEmitTable(false), shouldEmitMoves(false),
shouldEmitTableModule(false), shouldEmitMovesModule(false),
ExceptionTimer(0) {
for (std::vector<unsigned>::const_iterator
I = FilterIds.begin(), E = FilterIds.end(); I != E; ++I) {
FilterOffsets.push_back(Offset);
- Offset -= TargetAsmInfo::getULEB128Size(*I);
+ Offset -= MCAsmInfo::getULEB128Size(*I);
}
FirstActions.reserve(LandingPads.size());
const unsigned SizePrevIds = PrevLPI->TypeIds.size();
assert(Actions.size());
PrevAction = &Actions.back();
- SizeAction = TargetAsmInfo::getSLEB128Size(PrevAction->NextAction) +
- TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
+ SizeAction = MCAsmInfo::getSLEB128Size(PrevAction->NextAction) +
+ MCAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
for (unsigned j = NumShared; j != SizePrevIds; ++j) {
SizeAction -=
- TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
+ MCAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
SizeAction += -PrevAction->NextAction;
PrevAction = PrevAction->Previous;
}
int TypeID = TypeIds[J];
assert(-1 - TypeID < (int)FilterOffsets.size() && "Unknown filter id!");
int ValueForTypeID = TypeID < 0 ? FilterOffsets[-1 - TypeID] : TypeID;
- unsigned SizeTypeID = TargetAsmInfo::getSLEB128Size(ValueForTypeID);
+ unsigned SizeTypeID = MCAsmInfo::getSLEB128Size(ValueForTypeID);
int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0;
- SizeAction = SizeTypeID + TargetAsmInfo::getSLEB128Size(NextAction);
+ SizeAction = SizeTypeID + MCAsmInfo::getSLEB128Size(NextAction);
SizeSiteActions += SizeAction;
ActionEntry Action = { ValueForTypeID, NextAction, PrevAction };
SizeSites = CallSites.size() *
(SiteStartSize + SiteLengthSize + LandingPadSize);
for (unsigned i = 0, e = CallSites.size(); i < e; ++i) {
- SizeSites += TargetAsmInfo::getULEB128Size(CallSites[i].Action);
+ SizeSites += MCAsmInfo::getULEB128Size(CallSites[i].Action);
if (TAI->getExceptionHandlingType() == ExceptionHandling::SjLj)
- SizeSites += TargetAsmInfo::getULEB128Size(i);
+ SizeSites += MCAsmInfo::getULEB128Size(i);
}
// Type infos.
const unsigned TypeInfoSize = TD->getPointerSize(); // DW_EH_PE_absptr
unsigned SizeTypes = TypeInfos.size() * TypeInfoSize;
unsigned TypeOffset = sizeof(int8_t) + // Call site format
- TargetAsmInfo::getULEB128Size(SizeSites) + // Call-site table length
+ MCAsmInfo::getULEB128Size(SizeSites) + // Call-site table length
SizeSites + SizeActions + SizeTypes;
unsigned TotalSize = sizeof(int8_t) + // LPStart format
sizeof(int8_t) + // TType format
(HaveTTData ?
- TargetAsmInfo::getULEB128Size(TypeOffset) : 0) + // TType base offset
+ MCAsmInfo::getULEB128Size(TypeOffset) : 0) + // TType base offset
TypeOffset;
unsigned SizeAlign = (4 - TotalSize) & 3;
struct LandingPadInfo;
class MachineModuleInfo;
-class TargetAsmInfo;
+class MCAsmInfo;
class Timer;
class raw_ostream;
//===--------------------------------------------------------------------===//
// Main entry points.
//
- DwarfException(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T);
+ DwarfException(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T);
virtual ~DwarfException();
/// BeginModule - Emit all exception information that should come prior to the
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/Support/Dwarf.h"
#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetFrameInfo.h"
#include "llvm/Target/TargetRegisterInfo.h"
using namespace llvm;
-Dwarf::Dwarf(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T,
+Dwarf::Dwarf(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T,
const char *flavor)
: O(OS), Asm(A), TAI(T), TD(Asm->TM.getTargetData()),
RI(Asm->TM.getRegisterInfo()), M(NULL), MF(NULL), MMI(NULL),
class MachineFunction;
class MachineModuleInfo;
class Module;
- class TargetAsmInfo;
+ class MCAsmInfo;
class TargetData;
class TargetRegisterInfo;
/// TAI - Target asm information.
///
- const TargetAsmInfo *TAI;
+ const MCAsmInfo *TAI;
/// TD - Target data.
///
///
unsigned SetCounter;
- Dwarf(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T,
+ Dwarf(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T,
const char *flavor);
public:
//===------------------------------------------------------------------===//
//
const AsmPrinter *getAsm() const { return Asm; }
MachineModuleInfo *getMMI() const { return MMI; }
- const TargetAsmInfo *getTargetAsmInfo() const { return TAI; }
+ const MCAsmInfo *getMCAsmInfo() const { return TAI; }
const TargetData *getTargetData() const { return TD; }
void PrintRelDirective(bool Force32Bit = false,
void DwarfWriter::BeginModule(Module *M,
MachineModuleInfo *MMI,
raw_ostream &OS, AsmPrinter *A,
- const TargetAsmInfo *T) {
+ const MCAsmInfo *T) {
DE = new DwarfException(OS, A, T);
DD = new DwarfDebug(OS, A, T);
DE->BeginModule(M, MMI);
#include "llvm/CodeGen/GCMetadataPrinter.h"
#include "llvm/Module.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetMachine.h"
class VISIBILITY_HIDDEN OcamlGCMetadataPrinter : public GCMetadataPrinter {
public:
void beginAssembly(raw_ostream &OS, AsmPrinter &AP,
- const TargetAsmInfo &TAI);
+ const MCAsmInfo &TAI);
void finishAssembly(raw_ostream &OS, AsmPrinter &AP,
- const TargetAsmInfo &TAI);
+ const MCAsmInfo &TAI);
};
}
void llvm::linkOcamlGCPrinter() { }
static void EmitCamlGlobal(const Module &M, raw_ostream &OS, AsmPrinter &AP,
- const TargetAsmInfo &TAI, const char *Id) {
+ const MCAsmInfo &TAI, const char *Id) {
const std::string &MId = M.getModuleIdentifier();
std::string Mangled;
}
void OcamlGCMetadataPrinter::beginAssembly(raw_ostream &OS, AsmPrinter &AP,
- const TargetAsmInfo &TAI) {
+ const MCAsmInfo &TAI) {
AP.OutStreamer.SwitchSection(AP.getObjFileLowering().getTextSection());
EmitCamlGlobal(getModule(), OS, AP, TAI, "code_begin");
/// either condition is detected in a function which uses the GC.
///
void OcamlGCMetadataPrinter::finishAssembly(raw_ostream &OS, AsmPrinter &AP,
- const TargetAsmInfo &TAI) {
+ const MCAsmInfo &TAI) {
const char *AddressDirective;
int AddressAlignLog;
if (AP.TM.getTargetData()->getPointerSize() == sizeof(int32_t)) {
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetELFWriterInfo.h"
#include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCSectionELF.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetELFWriterInfo.h"
#include "llvm/Target/TargetLowering.h"
isLittleEndian(TM.getTargetData()->isLittleEndian()),
ElfHdr(isLittleEndian, is64Bit) {
- TAI = TM.getTargetAsmInfo();
+ TAI = TM.getMCAsmInfo();
TEW = TM.getELFWriterInfo();
// Create the object code emitter object for this target.
class MachineCodeEmitter;
class MachineConstantPoolEntry;
class ObjectCodeEmitter;
- class TargetAsmInfo;
+ class MCAsmInfo;
class TargetELFWriterInfo;
class TargetLoweringObjectFile;
class raw_ostream;
/// TAI - Target Asm Info, provide information about section names for
/// globals and other target specific stuff.
- const TargetAsmInfo *TAI;
+ const MCAsmInfo *TAI;
//===------------------------------------------------------------------===//
// Properties inferred automatically from the target machine.
GCMetadataPrinter::~GCMetadataPrinter() { }
void GCMetadataPrinter::beginAssembly(raw_ostream &OS, AsmPrinter &AP,
- const TargetAsmInfo &TAI) {
+ const MCAsmInfo &TAI) {
// Default is no action.
}
void GCMetadataPrinter::finishAssembly(raw_ostream &OS, AsmPrinter &AP,
- const TargetAsmInfo &TAI) {
+ const MCAsmInfo &TAI) {
// Default is no action.
}
#include "llvm/CodeGen/GCStrategy.h"
#include "llvm/CodeGen/MachineFunctionAnalysis.h"
#include "llvm/Target/TargetOptions.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetRegistry.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Support/CommandLine.h"
bool Verbose,
formatted_raw_ostream &Out) {
FunctionPass *Printer =
- getTarget().createAsmPrinter(Out, *this, getTargetAsmInfo(), Verbose);
+ getTarget().createAsmPrinter(Out, *this, getMCAsmInfo(), Verbose);
if (!Printer)
return true;
// Turn exception handling constructs into something the code generators can
// handle.
- switch (getTargetAsmInfo()->getExceptionHandlingType())
+ switch (getMCAsmInfo()->getExceptionHandlingType())
{
case ExceptionHandling::SjLj:
// SjLj piggy-backs on dwarf for this bit. The cleanups done apply to both
namespace llvm {
class GlobalValue;
-class TargetAsmInfo;
+class MCAsmInfo;
/// MachOSym - This struct contains information about each symbol that is
/// added to logical symbol table for the module. This is eventually
};
MachOSym(const GlobalValue *gv, std::string name, uint8_t sect,
- const TargetAsmInfo *TAI);
+ const MCAsmInfo *TAI);
struct SymCmp {
// FIXME: this does not appear to be sorting 'f' after 'F'
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineJumpTableInfo.h"
#include "llvm/CodeGen/MachineRelocation.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Support/ErrorHandling.h"
ObjectCodeEmitter(&mos), MOW(mow), TM(MOW.TM) {
is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64;
isLittleEndian = TM.getTargetData()->isLittleEndian();
- TAI = TM.getTargetAsmInfo();
+ TAI = TM.getMCAsmInfo();
}
/// startFunction - This callback is invoked when a new machine function is
/// machine directly, indicating what header values and flags to set.
bool is64Bit, isLittleEndian;
- const TargetAsmInfo *TAI;
+ const MCAsmInfo *TAI;
/// Relocations - These are the relocations that the function needs, as
/// emitted.
#include "llvm/DerivedTypes.h"
#include "llvm/Module.h"
#include "llvm/PassManager.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachOWriterInfo.h"
is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64;
isLittleEndian = TM.getTargetData()->isLittleEndian();
- TAI = TM.getTargetAsmInfo();
+ TAI = TM.getMCAsmInfo();
// Create the machine code emitter object for this target.
MachOCE = new MachOCodeEmitter(*this, *getTextSection(true));
//===----------------------------------------------------------------------===//
MachOSym::MachOSym(const GlobalValue *gv, std::string name, uint8_t sect,
- const TargetAsmInfo *TAI) :
+ const MCAsmInfo *TAI) :
GV(gv), n_strx(0), n_type(sect == NO_SECT ? N_UNDF : N_SECT), n_sect(sect),
n_desc(0), n_value(0) {
struct MachOSym;
class TargetData;
class TargetMachine;
- class TargetAsmInfo;
+ class MCAsmInfo;
class ObjectCodeEmitter;
class OutputBuffer;
class raw_ostream;
bool is64Bit, isLittleEndian;
// Target Asm Info
- const TargetAsmInfo *TAI;
+ const MCAsmInfo *TAI;
/// Header - An instance of MachOHeader that we will update while we build
/// the file, and then emit during finalization.
//===----------------------------------------------------------------------===//
#include "llvm/Target/TargetLowering.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetMachine.h"
InitLibcallCallingConvs(LibcallCallingConvs);
// Tell Legalize whether the assembler supports DEBUG_LOC.
- const TargetAsmInfo *TASM = TM.getTargetAsmInfo();
+ const MCAsmInfo *TASM = TM.getMCAsmInfo();
if (!TASM || !TASM->hasDotLocAndDotFile())
setOperationAction(ISD::DEBUG_LOC, MVT::Other, Expand);
}
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/ExecutionEngine/JITMemoryManager.h"
#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetFrameInfo.h"
unsigned char* EndFunction) {
const TargetMachine& TM = F.getTarget();
TD = TM.getTargetData();
- needsIndirectEncoding = TM.getTargetAsmInfo()->getNeedsIndirectEncoding();
+ needsIndirectEncoding = TM.getMCAsmInfo()->getNeedsIndirectEncoding();
stackGrowthDirection = TM.getFrameInfo()->getStackGrowthDirection();
RI = TM.getRegisterInfo();
JCE = &jce;
for(std::vector<unsigned>::const_iterator I = FilterIds.begin(),
E = FilterIds.end(); I != E; ++I) {
FilterOffsets.push_back(Offset);
- Offset -= TargetAsmInfo::getULEB128Size(*I);
+ Offset -= MCAsmInfo::getULEB128Size(*I);
}
// Compute the actions table and gather the first action index for each
const unsigned SizePrevIds = LandingPads[i-1]->TypeIds.size();
assert(Actions.size());
PrevAction = &Actions.back();
- SizeAction = TargetAsmInfo::getSLEB128Size(PrevAction->NextAction) +
- TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
+ SizeAction = MCAsmInfo::getSLEB128Size(PrevAction->NextAction) +
+ MCAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
for (unsigned j = NumShared; j != SizePrevIds; ++j) {
- SizeAction -= TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
+ SizeAction -= MCAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
SizeAction += -PrevAction->NextAction;
PrevAction = PrevAction->Previous;
}
int TypeID = TypeIds[I];
assert(-1-TypeID < (int)FilterOffsets.size() && "Unknown filter id!");
int ValueForTypeID = TypeID < 0 ? FilterOffsets[-1 - TypeID] : TypeID;
- unsigned SizeTypeID = TargetAsmInfo::getSLEB128Size(ValueForTypeID);
+ unsigned SizeTypeID = MCAsmInfo::getSLEB128Size(ValueForTypeID);
int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0;
- SizeAction = SizeTypeID + TargetAsmInfo::getSLEB128Size(NextAction);
+ SizeAction = SizeTypeID + MCAsmInfo::getSLEB128Size(NextAction);
SizeSiteActions += SizeAction;
ActionEntry Action = {ValueForTypeID, NextAction, PrevAction};
sizeof(int32_t) + // Site length.
sizeof(int32_t)); // Landing pad.
for (unsigned i = 0, e = CallSites.size(); i < e; ++i)
- SizeSites += TargetAsmInfo::getULEB128Size(CallSites[i].Action);
+ SizeSites += MCAsmInfo::getULEB128Size(CallSites[i].Action);
unsigned SizeTypes = TypeInfos.size() * TD->getPointerSize();
unsigned TypeOffset = sizeof(int8_t) + // Call site format
// Call-site table length
- TargetAsmInfo::getULEB128Size(SizeSites) +
+ MCAsmInfo::getULEB128Size(SizeSites) +
SizeSites + SizeActions + SizeTypes;
// Begin the exception table.
unsigned char* EndFunction) {
const TargetMachine& TM = F.getTarget();
TD = TM.getTargetData();
- needsIndirectEncoding = TM.getTargetAsmInfo()->getNeedsIndirectEncoding();
+ needsIndirectEncoding = TM.getMCAsmInfo()->getNeedsIndirectEncoding();
stackGrowthDirection = TM.getFrameInfo()->getStackGrowthDirection();
RI = TM.getRegisterInfo();
JCE = &jce;
// If there is a personality and landing pads then point to the language
// specific data area in the exception table.
if (MMI->getPersonalityIndex()) {
- FinalSize += TargetAsmInfo::getULEB128Size(4);
+ FinalSize += MCAsmInfo::getULEB128Size(4);
FinalSize += PointerSize;
} else {
- FinalSize += TargetAsmInfo::getULEB128Size(0);
+ FinalSize += MCAsmInfo::getULEB128Size(0);
}
// Indicate locations of function specific callee saved registers in
FinalSize += 4;
FinalSize += 1;
FinalSize += Personality ? 5 : 3; // "zPLR" or "zR"
- FinalSize += TargetAsmInfo::getULEB128Size(1);
- FinalSize += TargetAsmInfo::getSLEB128Size(stackGrowth);
+ FinalSize += MCAsmInfo::getULEB128Size(1);
+ FinalSize += MCAsmInfo::getSLEB128Size(stackGrowth);
FinalSize += 1;
if (Personality) {
- FinalSize += TargetAsmInfo::getULEB128Size(7);
+ FinalSize += MCAsmInfo::getULEB128Size(7);
// Encoding
FinalSize+= 1;
//Personality
FinalSize += PointerSize;
- FinalSize += TargetAsmInfo::getULEB128Size(dwarf::DW_EH_PE_pcrel);
- FinalSize += TargetAsmInfo::getULEB128Size(dwarf::DW_EH_PE_pcrel);
+ FinalSize += MCAsmInfo::getULEB128Size(dwarf::DW_EH_PE_pcrel);
+ FinalSize += MCAsmInfo::getULEB128Size(dwarf::DW_EH_PE_pcrel);
} else {
- FinalSize += TargetAsmInfo::getULEB128Size(1);
- FinalSize += TargetAsmInfo::getULEB128Size(dwarf::DW_EH_PE_pcrel);
+ FinalSize += MCAsmInfo::getULEB128Size(1);
+ FinalSize += MCAsmInfo::getULEB128Size(dwarf::DW_EH_PE_pcrel);
}
std::vector<MachineMove> Moves;
} else {
++FinalSize;
unsigned RegNum = RI->getDwarfRegNum(Src.getReg(), true);
- FinalSize += TargetAsmInfo::getULEB128Size(RegNum);
+ FinalSize += MCAsmInfo::getULEB128Size(RegNum);
}
int Offset = -Src.getOffset();
- FinalSize += TargetAsmInfo::getULEB128Size(Offset);
+ FinalSize += MCAsmInfo::getULEB128Size(Offset);
} else {
llvm_unreachable("Machine move no supported yet.");
}
if (Dst.isReg()) {
++FinalSize;
unsigned RegNum = RI->getDwarfRegNum(Dst.getReg(), true);
- FinalSize += TargetAsmInfo::getULEB128Size(RegNum);
+ FinalSize += MCAsmInfo::getULEB128Size(RegNum);
} else {
llvm_unreachable("Machine move no supported yet.");
}
if (Offset < 0) {
++FinalSize;
- FinalSize += TargetAsmInfo::getULEB128Size(Reg);
- FinalSize += TargetAsmInfo::getSLEB128Size(Offset);
+ FinalSize += MCAsmInfo::getULEB128Size(Reg);
+ FinalSize += MCAsmInfo::getSLEB128Size(Offset);
} else if (Reg < 64) {
++FinalSize;
- FinalSize += TargetAsmInfo::getULEB128Size(Offset);
+ FinalSize += MCAsmInfo::getULEB128Size(Offset);
} else {
++FinalSize;
- FinalSize += TargetAsmInfo::getULEB128Size(Reg);
- FinalSize += TargetAsmInfo::getULEB128Size(Offset);
+ FinalSize += MCAsmInfo::getULEB128Size(Reg);
+ FinalSize += MCAsmInfo::getULEB128Size(Offset);
}
}
}
for(std::vector<unsigned>::const_iterator I = FilterIds.begin(),
E = FilterIds.end(); I != E; ++I) {
FilterOffsets.push_back(Offset);
- Offset -= TargetAsmInfo::getULEB128Size(*I);
+ Offset -= MCAsmInfo::getULEB128Size(*I);
}
// Compute the actions table and gather the first action index for each
const unsigned SizePrevIds = LandingPads[i-1]->TypeIds.size();
assert(Actions.size());
PrevAction = &Actions.back();
- SizeAction = TargetAsmInfo::getSLEB128Size(PrevAction->NextAction) +
- TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
+ SizeAction = MCAsmInfo::getSLEB128Size(PrevAction->NextAction) +
+ MCAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
for (unsigned j = NumShared; j != SizePrevIds; ++j) {
- SizeAction -= TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
+ SizeAction -= MCAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
SizeAction += -PrevAction->NextAction;
PrevAction = PrevAction->Previous;
}
int TypeID = TypeIds[I];
assert(-1-TypeID < (int)FilterOffsets.size() && "Unknown filter id!");
int ValueForTypeID = TypeID < 0 ? FilterOffsets[-1 - TypeID] : TypeID;
- unsigned SizeTypeID = TargetAsmInfo::getSLEB128Size(ValueForTypeID);
+ unsigned SizeTypeID = MCAsmInfo::getSLEB128Size(ValueForTypeID);
int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0;
- SizeAction = SizeTypeID + TargetAsmInfo::getSLEB128Size(NextAction);
+ SizeAction = SizeTypeID + MCAsmInfo::getSLEB128Size(NextAction);
SizeSiteActions += SizeAction;
ActionEntry Action = {ValueForTypeID, NextAction, PrevAction};
sizeof(int32_t) + // Site length.
sizeof(int32_t)); // Landing pad.
for (unsigned i = 0, e = CallSites.size(); i < e; ++i)
- SizeSites += TargetAsmInfo::getULEB128Size(CallSites[i].Action);
+ SizeSites += MCAsmInfo::getULEB128Size(CallSites[i].Action);
unsigned SizeTypes = TypeInfos.size() * TD->getPointerSize();
unsigned TypeOffset = sizeof(int8_t) + // Call site format
// Call-site table length
- TargetAsmInfo::getULEB128Size(SizeSites) +
+ MCAsmInfo::getULEB128Size(SizeSites) +
SizeSites + SizeActions + SizeTypes;
unsigned TotalSize = sizeof(int8_t) + // LPStart format
sizeof(int8_t) + // TType format
- TargetAsmInfo::getULEB128Size(TypeOffset) + // TType base offset
+ MCAsmInfo::getULEB128Size(TypeOffset) + // TType base offset
TypeOffset;
unsigned SizeAlign = (4 - TotalSize) & 3;
// Asm->EOL("Landing pad");
FinalSize += PointerSize;
- FinalSize += TargetAsmInfo::getULEB128Size(S.Action);
+ FinalSize += MCAsmInfo::getULEB128Size(S.Action);
// Asm->EOL("Action");
}
ActionEntry &Action = Actions[I];
//Asm->EOL("TypeInfo index");
- FinalSize += TargetAsmInfo::getSLEB128Size(Action.ValueForTypeID);
+ FinalSize += MCAsmInfo::getSLEB128Size(Action.ValueForTypeID);
//Asm->EOL("Next action");
- FinalSize += TargetAsmInfo::getSLEB128Size(Action.NextAction);
+ FinalSize += MCAsmInfo::getSLEB128Size(Action.NextAction);
}
// Emit the type ids.
// Emit the filter typeids.
for (unsigned j = 0, M = FilterIds.size(); j < M; ++j) {
unsigned TypeID = FilterIds[j];
- FinalSize += TargetAsmInfo::getULEB128Size(TypeID);
+ FinalSize += MCAsmInfo::getULEB128Size(TypeID);
//Asm->EOL("Filter TypeInfo index");
}
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCValue.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
class MCAsmStreamer : public MCStreamer {
raw_ostream &OS;
- const TargetAsmInfo &TAI;
+ const MCAsmInfo &TAI;
AsmPrinter *Printer;
public:
- MCAsmStreamer(MCContext &Context, raw_ostream &_OS, const TargetAsmInfo &tai,
+ MCAsmStreamer(MCContext &Context, raw_ostream &_OS, const MCAsmInfo &tai,
AsmPrinter *_AsmPrinter)
: MCStreamer(Context), OS(_OS), TAI(tai), Printer(_AsmPrinter) {}
~MCAsmStreamer() {}
}
MCStreamer *llvm::createAsmStreamer(MCContext &Context, raw_ostream &OS,
- const TargetAsmInfo &TAI, AsmPrinter *AP) {
+ const MCAsmInfo &TAI, AsmPrinter *AP) {
return new MCAsmStreamer(Context, OS, TAI, AP);
}
#include "llvm/MC/MCSection.h"
#include "llvm/MC/MCContext.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
return new (Ctx) MCSectionCOFF(Name, IsDirective, K);
}
-void MCSectionCOFF::PrintSwitchToSection(const TargetAsmInfo &TAI,
+void MCSectionCOFF::PrintSwitchToSection(const MCAsmInfo &TAI,
raw_ostream &OS) const {
if (isDirective()) {
#include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCContext.h"
#include "llvm/Support/raw_ostream.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
using namespace llvm;
// ShouldOmitSectionDirective - Decides whether a '.section' directive
// should be printed before the section name
bool MCSectionELF::ShouldOmitSectionDirective(const char *Name,
- const TargetAsmInfo &TAI) const {
+ const MCAsmInfo &TAI) const {
// FIXME: Does .section .bss/.data/.text work everywhere??
if (strcmp(Name, ".text") == 0 ||
return true;
}
-void MCSectionELF::PrintSwitchToSection(const TargetAsmInfo &TAI,
+void MCSectionELF::PrintSwitchToSection(const MCAsmInfo &TAI,
raw_ostream &OS) const {
if (ShouldOmitSectionDirective(SectionName.c_str(), TAI)) {
Reserved2, K);
}
-void MCSectionMachO::PrintSwitchToSection(const TargetAsmInfo &TAI,
+void MCSectionMachO::PrintSwitchToSection(const MCAsmInfo &TAI,
raw_ostream &OS) const {
OS << "\t.section\t" << getSegmentName() << ',' << getSectionName();
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineJumpTableInfo.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorHandling.h"
using namespace llvm;
unsigned ARMBaseInstrInfo::GetInstSizeInBytes(const MachineInstr *MI) const {
const MachineBasicBlock &MBB = *MI->getParent();
const MachineFunction *MF = MBB.getParent();
- const TargetAsmInfo *TAI = MF->getTarget().getTargetAsmInfo();
+ const MCAsmInfo *TAI = MF->getTarget().getMCAsmInfo();
// Basic size info comes from the TSFlags field.
const TargetInstrDesc &TID = MI->getDesc();
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineJumpTableInfo.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Support/CommandLine.h"
using namespace llvm;
-//===-- ARMTargetAsmInfo.cpp - ARM asm properties ---------------*- C++ -*-===//
+//===-- ARMMCAsmInfo.cpp - ARM asm properties -------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the ARMTargetAsmInfo properties.
+// This file contains the declarations of the ARMMCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "ARMTargetAsmInfo.h"
+#include "ARMMCAsmInfo.h"
using namespace llvm;
static const char *const arm_asm_table[] = {
0,0
};
-ARMDarwinTargetAsmInfo::ARMDarwinTargetAsmInfo() {
+ARMDarwinMCAsmInfo::ARMDarwinMCAsmInfo() {
AsmTransCBE = arm_asm_table;
Data64bitsDirective = 0;
CommentString = "@";
AbsoluteEHSectionOffsets = false;
}
-ARMELFTargetAsmInfo::ARMELFTargetAsmInfo() {
+ARMELFMCAsmInfo::ARMELFMCAsmInfo() {
AlignmentIsInBytes = false;
Data64bitsDirective = 0;
CommentString = "@";
-//=====-- ARMTargetAsmInfo.h - ARM asm properties -------------*- C++ -*--====//
+//=====-- ARMMCAsmInfo.h - ARM asm properties -------------*- C++ -*--====//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the ARMTargetAsmInfo class.
+// This file contains the declaration of the ARMMCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ARMTARGETASMINFO_H
#define LLVM_ARMTARGETASMINFO_H
-#include "llvm/Target/DarwinTargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfoDarwin.h"
namespace llvm {
- struct ARMDarwinTargetAsmInfo : public DarwinTargetAsmInfo {
- explicit ARMDarwinTargetAsmInfo();
+ struct ARMDarwinMCAsmInfo : public DarwinMCAsmInfo {
+ explicit ARMDarwinMCAsmInfo();
};
- struct ARMELFTargetAsmInfo : public TargetAsmInfo {
- explicit ARMELFTargetAsmInfo();
+ struct ARMELFMCAsmInfo : public MCAsmInfo {
+ explicit ARMELFMCAsmInfo();
};
} // namespace llvm
//===----------------------------------------------------------------------===//
#include "ARMTargetMachine.h"
-#include "ARMTargetAsmInfo.h"
+#include "ARMMCAsmInfo.h"
#include "ARMFrameInfo.h"
#include "ARM.h"
#include "llvm/PassManager.h"
static cl::opt<bool> DisableIfConversion("disable-arm-if-conversion",cl::Hidden,
cl::desc("Disable if-conversion pass"));
-static const TargetAsmInfo *createTargetAsmInfo(const Target &T,
+static const MCAsmInfo *createMCAsmInfo(const Target &T,
const StringRef &TT) {
Triple TheTriple(TT);
switch (TheTriple.getOS()) {
case Triple::Darwin:
- return new ARMDarwinTargetAsmInfo();
+ return new ARMDarwinMCAsmInfo();
default:
- return new ARMELFTargetAsmInfo();
+ return new ARMELFMCAsmInfo();
}
}
RegisterTargetMachine<ThumbTargetMachine> Y(TheThumbTarget);
// Register the target asm info.
- RegisterAsmInfoFn A(TheARMTarget, createTargetAsmInfo);
- RegisterAsmInfoFn B(TheThumbTarget, createTargetAsmInfo);
+ RegisterAsmInfoFn A(TheARMTarget, createMCAsmInfo);
+ RegisterAsmInfoFn B(TheThumbTarget, createMCAsmInfo);
}
/// TargetMachine ctor - Create an ARM architecture model.
#include "llvm/CodeGen/MachineJumpTableInfo.h"
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetMachine.h"
bool InCPMode;
public:
explicit ARMAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V), DW(0), AFI(NULL), MCP(NULL),
InCPMode(false) {
Subtarget = &TM.getSubtarget<ARMSubtarget>();
}
static void printSOImm(formatted_raw_ostream &O, int64_t V, bool VerboseAsm,
- const TargetAsmInfo *TAI) {
+ const MCAsmInfo *TAI) {
// Break it up into two parts that make up a shifter immediate.
V = ARM_AM::getSOImmVal(V);
assert(V != -1 && "Not a valid so_imm value!");
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
using namespace llvm;
namespace {
-//===-- AlphaTargetAsmInfo.cpp - Alpha asm properties -----------*- C++ -*-===//
+//===-- AlphaMCAsmInfo.cpp - Alpha asm properties ---------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the AlphaTargetAsmInfo properties.
+// This file contains the declarations of the AlphaMCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "AlphaTargetAsmInfo.h"
+#include "AlphaMCAsmInfo.h"
using namespace llvm;
-AlphaTargetAsmInfo::AlphaTargetAsmInfo(const Target &T, const StringRef &TT) {
+AlphaMCAsmInfo::AlphaMCAsmInfo(const Target &T, const StringRef &TT) {
AlignmentIsInBytes = false;
PrivateGlobalPrefix = "$";
PICJumpTableDirective = ".gprel32";
-//=====-- AlphaTargetAsmInfo.h - Alpha asm properties ---------*- C++ -*--====//
+//=====-- AlphaMCAsmInfo.h - Alpha asm properties -------------*- C++ -*--====//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the AlphaTargetAsmInfo class.
+// This file contains the declaration of the AlphaMCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef ALPHATARGETASMINFO_H
#define ALPHATARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class Target;
class StringRef;
- struct AlphaTargetAsmInfo : public TargetAsmInfo {
- explicit AlphaTargetAsmInfo(const Target &T, const StringRef &TT);
+ struct AlphaMCAsmInfo : public MCAsmInfo {
+ explicit AlphaMCAsmInfo(const Target &T, const StringRef &TT);
};
} // namespace llvm
#include "Alpha.h"
#include "AlphaJITInfo.h"
-#include "AlphaTargetAsmInfo.h"
+#include "AlphaMCAsmInfo.h"
#include "AlphaTargetMachine.h"
#include "llvm/PassManager.h"
#include "llvm/Support/FormattedStream.h"
extern "C" void LLVMInitializeAlphaTarget() {
// Register the target.
RegisterTargetMachine<AlphaTargetMachine> X(TheAlphaTarget);
- RegisterAsmInfo<AlphaTargetAsmInfo> Y(TheAlphaTarget);
+ RegisterAsmInfo<AlphaMCAsmInfo> Y(TheAlphaTarget);
}
AlphaTargetMachine::AlphaTargetMachine(const Target &T, const std::string &TT,
#include "llvm/CodeGen/AsmPrinter.h"
#include "llvm/CodeGen/DwarfWriter.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetRegistry.h"
///
explicit AlphaAsmPrinter(formatted_raw_ostream &o, TargetMachine &tm,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: AsmPrinter(o, tm, T, V) {}
virtual const char *getPassName() const {
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetRegistry.h"
class VISIBILITY_HIDDEN BlackfinAsmPrinter : public AsmPrinter {
public:
BlackfinAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *TAI, bool V)
+ const MCAsmInfo *TAI, bool V)
: AsmPrinter(O, TM, TAI, V) {}
virtual const char *getPassName() const {
-//===-- BlackfinTargetAsmInfo.cpp - Blackfin asm properties -----*- C++ -*-===//
+//===-- BlackfinMCAsmInfo.cpp - Blackfin asm properties -------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the BlackfinTargetAsmInfo properties.
+// This file contains the declarations of the BlackfinMCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "BlackfinTargetAsmInfo.h"
+#include "BlackfinMCAsmInfo.h"
using namespace llvm;
-BlackfinTargetAsmInfo::BlackfinTargetAsmInfo(const Target &T,
- const StringRef &TT) {
+BlackfinMCAsmInfo::BlackfinMCAsmInfo(const Target &T, const StringRef &TT) {
GlobalPrefix = "_";
CommentString = "//";
}
-//===-- BlackfinTargetAsmInfo.h - Blackfin asm properties -----*- C++ -*--====//
+//===-- BlackfinMCAsmInfo.h - Blackfin asm properties ---------*- C++ -*--====//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the BlackfinTargetAsmInfo class.
+// This file contains the declaration of the BlackfinMCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef BLACKFINTARGETASMINFO_H
#define BLACKFINTARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class Target;
class StringRef;
- struct BlackfinTargetAsmInfo : public TargetAsmInfo {
- explicit BlackfinTargetAsmInfo(const Target &T, const StringRef &TT);
+ struct BlackfinMCAsmInfo : public MCAsmInfo {
+ explicit BlackfinMCAsmInfo(const Target &T, const StringRef &TT);
};
} // namespace llvm
#include "BlackfinTargetMachine.h"
#include "Blackfin.h"
-#include "BlackfinTargetAsmInfo.h"
+#include "BlackfinMCAsmInfo.h"
#include "llvm/PassManager.h"
#include "llvm/Target/TargetRegistry.h"
extern "C" void LLVMInitializeBlackfinTarget() {
RegisterTargetMachine<BlackfinTargetMachine> X(TheBlackfinTarget);
- RegisterAsmInfo<BlackfinTargetAsmInfo> Y(TheBlackfinTarget);
+ RegisterAsmInfo<BlackfinMCAsmInfo> Y(TheBlackfinTarget);
}
#include "llvm/CodeGen/Passes.h"
#include "llvm/CodeGen/IntrinsicLowering.h"
#include "llvm/Transforms/Scalar.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetRegistry.h"
#include "llvm/Support/CallSite.h"
Mangler *Mang;
LoopInfo *LI;
const Module *TheModule;
- const TargetAsmInfo* TAsm;
+ const MCAsmInfo* TAsm;
const TargetData* TD;
std::map<const Type *, std::string> TypeNames;
std::map<const ConstantFP *, unsigned> FPConstantMap;
const char *const *table = 0;
- // Grab the translation table from TargetAsmInfo if it exists.
+ // Grab the translation table from MCAsmInfo if it exists.
if (!TAsm) {
std::string Triple = TheModule->getTargetTriple();
if (Triple.empty())
-//===-- COFFTargetAsmInfo.cpp - COFF asm properties -------------*- C++ -*-===//
+//===-- COFFMCAsmInfo.cpp - COFF asm properties -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#include "llvm/Target/COFFTargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfoCOFF.h"
#include "llvm/ADT/SmallVector.h"
using namespace llvm;
-COFFTargetAsmInfo::COFFTargetAsmInfo() {
+COFFMCAsmInfo::COFFMCAsmInfo() {
GlobalPrefix = "_";
LCOMMDirective = "\t.lcomm\t";
COMMDirectiveTakesAlignment = false;
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetOptions.h"
std::set<std::string> FnStubs, GVStubs;
public:
explicit SPUAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V) :
+ const MCAsmInfo *T, bool V) :
AsmPrinter(O, TM, T, V) {}
virtual const char *getPassName() const {
DwarfWriter *DW;
public:
explicit LinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: SPUAsmPrinter(O, TM, T, V), DW(0) {}
virtual const char *getPassName() const {
-//===-- SPUTargetAsmInfo.cpp - Cell SPU asm properties ----------*- C++ -*-===//
+//===-- SPUMCAsmInfo.cpp - Cell SPU asm properties ------------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the SPUTargetAsmInfo properties.
+// This file contains the declarations of the SPUMCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "SPUTargetAsmInfo.h"
+#include "SPUMCAsmInfo.h"
using namespace llvm;
-SPULinuxTargetAsmInfo::SPULinuxTargetAsmInfo(const Target &T, const StringRef &TT) {
+SPULinuxMCAsmInfo::SPULinuxMCAsmInfo(const Target &T, const StringRef &TT) {
ZeroDirective = "\t.space\t";
SetDirective = "\t.set";
Data64bitsDirective = "\t.quad\t";
-//===-- SPUTargetAsmInfo.h - Cell SPU asm properties -----------*- C++ -*--===//
+//===-- SPUMCAsmInfo.h - Cell SPU asm properties ---------------*- C++ -*--===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the SPUTargetAsmInfo class.
+// This file contains the declaration of the SPUMCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef SPUTARGETASMINFO_H
#define SPUTARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class Target;
class StringRef;
- struct SPULinuxTargetAsmInfo : public TargetAsmInfo {
- explicit SPULinuxTargetAsmInfo(const Target &T, const StringRef &TT);
+ struct SPULinuxMCAsmInfo : public MCAsmInfo {
+ explicit SPULinuxMCAsmInfo(const Target &T, const StringRef &TT);
};
} // namespace llvm
#include "SPU.h"
#include "SPURegisterNames.h"
-#include "SPUTargetAsmInfo.h"
+#include "SPUMCAsmInfo.h"
#include "SPUTargetMachine.h"
#include "llvm/PassManager.h"
#include "llvm/CodeGen/RegAllocRegistry.h"
extern "C" void LLVMInitializeCellSPUTarget() {
// Register the target.
RegisterTargetMachine<SPUTargetMachine> X(TheCellSPUTarget);
- RegisterAsmInfo<SPULinuxTargetAsmInfo> Y(TheCellSPUTarget);
+ RegisterAsmInfo<SPULinuxMCAsmInfo> Y(TheCellSPUTarget);
}
const std::pair<unsigned, int> *
-//===-- DarwinTargetAsmInfo.cpp - Darwin asm properties ---------*- C++ -*-===//
+//===-- MCAsmInfoDarwin.cpp - Darwin asm properties -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#include "llvm/Target/DarwinTargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfoDarwin.h"
using namespace llvm;
-DarwinTargetAsmInfo::DarwinTargetAsmInfo() {
+DarwinMCAsmInfo::DarwinMCAsmInfo() {
// Common settings for all Darwin targets.
// Syntax:
GlobalPrefix = "_";
#define DEBUG_TYPE "asm-printer"
#include "MSP430.h"
#include "MSP430InstrInfo.h"
-#include "MSP430TargetAsmInfo.h"
+#include "MSP430MCAsmInfo.h"
#include "MSP430TargetMachine.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
class VISIBILITY_HIDDEN MSP430AsmPrinter : public AsmPrinter {
public:
MSP430AsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *TAI, bool V)
+ const MCAsmInfo *TAI, bool V)
: AsmPrinter(O, TM, TAI, V) {}
virtual const char *getPassName() const {
-//===-- MSP430TargetAsmInfo.cpp - MSP430 asm properties -------------------===//
+//===-- MSP430MCAsmInfo.cpp - MSP430 asm properties -----------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the MSP430TargetAsmInfo properties.
+// This file contains the declarations of the MSP430MCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "MSP430TargetAsmInfo.h"
+#include "MSP430MCAsmInfo.h"
using namespace llvm;
-MSP430TargetAsmInfo::MSP430TargetAsmInfo(const Target &T, const StringRef &TT) {
+MSP430MCAsmInfo::MSP430MCAsmInfo(const Target &T, const StringRef &TT) {
AlignmentIsInBytes = false;
}
-//=====-- MSP430TargetAsmInfo.h - MSP430 asm properties -------*- C++ -*--====//
+//=====-- MSP430MCAsmInfo.h - MSP430 asm properties -----------*- C++ -*--====//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the MSP430TargetAsmInfo class.
+// This file contains the declaration of the MSP430MCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef MSP430TARGETASMINFO_H
#define MSP430TARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class Target;
class StringRef;
- struct MSP430TargetAsmInfo : public TargetAsmInfo {
- explicit MSP430TargetAsmInfo(const Target &T, const StringRef &TT);
+ struct MSP430MCAsmInfo : public MCAsmInfo {
+ explicit MSP430MCAsmInfo(const Target &T, const StringRef &TT);
};
} // namespace llvm
//===----------------------------------------------------------------------===//
#include "MSP430.h"
-#include "MSP430TargetAsmInfo.h"
+#include "MSP430MCAsmInfo.h"
#include "MSP430TargetMachine.h"
#include "llvm/PassManager.h"
#include "llvm/CodeGen/Passes.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetRegistry.h"
using namespace llvm;
extern "C" void LLVMInitializeMSP430Target() {
// Register the target.
RegisterTargetMachine<MSP430TargetMachine> X(TheMSP430Target);
- RegisterAsmInfo<MSP430TargetAsmInfo> Z(TheMSP430Target);
+ RegisterAsmInfo<MSP430MCAsmInfo> Z(TheMSP430Target);
}
MSP430TargetMachine::MSP430TargetMachine(const Target &T,
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetMachine.h"
const MipsSubtarget *Subtarget;
public:
explicit MipsAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V) {
Subtarget = &TM.getSubtarget<MipsSubtarget>();
}
-//===-- MipsTargetAsmInfo.cpp - Mips asm properties -------------*- C++ -*-===//
+//===-- MipsMCAsmInfo.cpp - Mips asm properties ---------------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the MipsTargetAsmInfo properties.
+// This file contains the declarations of the MipsMCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "MipsTargetAsmInfo.h"
+#include "MipsMCAsmInfo.h"
using namespace llvm;
-MipsTargetAsmInfo::MipsTargetAsmInfo(const Target &T, const StringRef &TT) {
+MipsMCAsmInfo::MipsMCAsmInfo(const Target &T, const StringRef &TT) {
AlignmentIsInBytes = false;
COMMDirectiveTakesAlignment = true;
Data16bitsDirective = "\t.half\t";
-//=====-- MipsTargetAsmInfo.h - Mips asm properties -----------*- C++ -*--====//
+//=====-- MipsMCAsmInfo.h - Mips asm properties ---------------*- C++ -*--====//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the MipsTargetAsmInfo class.
+// This file contains the declaration of the MipsMCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef MIPSTARGETASMINFO_H
#define MIPSTARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class Target;
class StringRef;
- class MipsTargetAsmInfo : public TargetAsmInfo {
+ class MipsMCAsmInfo : public MCAsmInfo {
public:
- explicit MipsTargetAsmInfo(const Target &T, const StringRef &TT);
+ explicit MipsMCAsmInfo(const Target &T, const StringRef &TT);
};
} // namespace llvm
//===----------------------------------------------------------------------===//
#include "Mips.h"
-#include "MipsTargetAsmInfo.h"
+#include "MipsMCAsmInfo.h"
#include "MipsTargetMachine.h"
#include "llvm/PassManager.h"
#include "llvm/Target/TargetRegistry.h"
// Register the target.
RegisterTargetMachine<MipsTargetMachine> X(TheMipsTarget);
RegisterTargetMachine<MipselTargetMachine> Y(TheMipselTarget);
- RegisterAsmInfo<MipsTargetAsmInfo> A(TheMipsTarget);
- RegisterAsmInfo<MipsTargetAsmInfo> B(TheMipselTarget);
+ RegisterAsmInfo<MipsMCAsmInfo> A(TheMipsTarget);
+ RegisterAsmInfo<MipsMCAsmInfo> B(TheMipselTarget);
}
// DataLayout --> Big-endian, 32-bit pointer/ABI/alignment
#include "PIC16AsmPrinter.h"
#include "MCSectionPIC16.h"
-#include "PIC16TargetAsmInfo.h"
+#include "PIC16MCAsmInfo.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/Module.h"
#include "PIC16GenAsmWriter.inc"
PIC16AsmPrinter::PIC16AsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V), DbgInfo(O, T) {
PTLI = static_cast<PIC16TargetLowering*>(TM.getTargetLowering());
- PTAI = static_cast<const PIC16TargetAsmInfo*>(T);
+ PTAI = static_cast<const PIC16MCAsmInfo*>(T);
PTOF = (PIC16TargetObjectFile*)&PTLI->getObjFileLowering();
}
#include "PIC16.h"
#include "PIC16TargetMachine.h"
#include "PIC16DebugInfo.h"
+#include "PIC16MCAsmInfo.h"
#include "PIC16TargetObjectFile.h"
#include "llvm/Analysis/DebugInfo.h"
-#include "PIC16TargetAsmInfo.h"
#include "llvm/CodeGen/AsmPrinter.h"
#include "llvm/Support/CommandLine.h"
-#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetMachine.h"
#include <list>
#include <string>
class VISIBILITY_HIDDEN PIC16AsmPrinter : public AsmPrinter {
public:
explicit PIC16AsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V);
+ const MCAsmInfo *T, bool V);
private:
virtual const char *getPassName() const {
return "PIC16 Assembly Printer";
PIC16TargetObjectFile *PTOF;
PIC16TargetLowering *PTLI;
PIC16DbgInfo DbgInfo;
- const PIC16TargetAsmInfo *PTAI;
+ const PIC16MCAsmInfo *PTAI;
std::list<const char *> LibcallDecls; // List of extern decls.
};
} // end of namespace
static MCSectionPIC16 *Create(const StringRef &Name,
SectionKind K, MCContext &Ctx);
- virtual void PrintSwitchToSection(const TargetAsmInfo &TAI,
+ virtual void PrintSwitchToSection(const MCAsmInfo &TAI,
raw_ostream &OS) const;
};
#include "llvm/Analysis/DebugInfo.h"
#include "llvm/Module.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include <map>
namespace llvm {
class PIC16DbgInfo {
formatted_raw_ostream &O;
- const TargetAsmInfo *TAI;
+ const MCAsmInfo *TAI;
std::string CurFile;
unsigned CurLine;
bool EmitDebugDirectives;
public:
- PIC16DbgInfo(formatted_raw_ostream &o, const TargetAsmInfo *T)
+ PIC16DbgInfo(formatted_raw_ostream &o, const MCAsmInfo *T)
: O(o), TAI(T) {
CurFile = "";
CurLine = 0;
-//===-- PIC16TargetAsmInfo.cpp - PIC16 asm properties ---------------------===//
+//===-- PIC16MCAsmInfo.cpp - PIC16 asm properties -------------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the PIC16TargetAsmInfo properties.
+// This file contains the declarations of the PIC16MCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "PIC16TargetAsmInfo.h"
+#include "PIC16MCAsmInfo.h"
// FIXME: Layering violation to get enums and static function, should be moved
// to separate headers.
#include "PIC16ISelLowering.h"
using namespace llvm;
-PIC16TargetAsmInfo::PIC16TargetAsmInfo(const Target &T, const StringRef &TT) {
+PIC16MCAsmInfo::PIC16MCAsmInfo(const Target &T, const StringRef &TT) {
CommentString = ";";
GlobalPrefix = PAN::getTagName(PAN::PREFIX_SYMBOL);
GlobalDirective = "\tglobal\t";
HasSingleParameterDotFile = false;
}
-const char *PIC16TargetAsmInfo::
-getDataASDirective(unsigned Size, unsigned AS) const {
+const char *PIC16MCAsmInfo::getDataASDirective(unsigned Size,
+ unsigned AS) const {
if (AS != PIC16ISD::ROM_SPACE)
return 0;
-//=====-- PIC16TargetAsmInfo.h - PIC16 asm properties ---------*- C++ -*--====//
+//=====-- PIC16MCAsmInfo.h - PIC16 asm properties -------------*- C++ -*--====//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the PIC16TargetAsmInfo class.
+// This file contains the declaration of the PIC16MCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef PIC16TARGETASMINFO_H
#define PIC16TARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class Target;
class StringRef;
- class PIC16TargetAsmInfo : public TargetAsmInfo {
+ class PIC16MCAsmInfo : public MCAsmInfo {
const char *RomData8bitsDirective;
const char *RomData16bitsDirective;
const char *RomData32bitsDirective;
public:
- PIC16TargetAsmInfo(const Target &T, const StringRef &TT);
+ PIC16MCAsmInfo(const Target &T, const StringRef &TT);
virtual const char *getDataASDirective(unsigned size, unsigned AS) const;
};
#define DEBUG_TYPE "pic16-codegen"
#include "PIC16.h"
#include "PIC16InstrInfo.h"
-#include "PIC16TargetAsmInfo.h"
+#include "PIC16MCAsmInfo.h"
#include "PIC16TargetMachine.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
//===----------------------------------------------------------------------===//
#include "PIC16.h"
-#include "PIC16TargetAsmInfo.h"
+#include "PIC16MCAsmInfo.h"
#include "PIC16TargetMachine.h"
#include "llvm/PassManager.h"
#include "llvm/CodeGen/Passes.h"
// Register the target. Curretnly the codegen works for
// enhanced pic16 mid-range.
RegisterTargetMachine<PIC16TargetMachine> X(ThePIC16Target);
- RegisterAsmInfo<PIC16TargetAsmInfo> A(ThePIC16Target);
+ RegisterAsmInfo<PIC16MCAsmInfo> A(ThePIC16Target);
}
}
-void MCSectionPIC16::PrintSwitchToSection(const TargetAsmInfo &TAI,
+void MCSectionPIC16::PrintSwitchToSection(const MCAsmInfo &TAI,
raw_ostream &OS) const {
OS << getName() << '\n';
}
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
uint64_t LabelID;
public:
explicit PPCAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V),
Subtarget(TM.getSubtarget<PPCSubtarget>()), LabelID(0) {}
class VISIBILITY_HIDDEN PPCLinuxAsmPrinter : public PPCAsmPrinter {
public:
explicit PPCLinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: PPCAsmPrinter(O, TM, T, V){}
virtual const char *getPassName() const {
formatted_raw_ostream &OS;
public:
explicit PPCDarwinAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: PPCAsmPrinter(O, TM, T, V), OS(O) {}
virtual const char *getPassName() const {
///
static AsmPrinter *createPPCAsmPrinterPass(formatted_raw_ostream &o,
TargetMachine &tm,
- const TargetAsmInfo *tai,
+ const MCAsmInfo *tai,
bool verbose) {
const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>();
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
using namespace llvm;
extern cl::opt<bool> EnablePPC32RS; // FIXME (64-bit): See PPCRegisterInfo.cpp.
case PPC::INLINEASM: { // Inline Asm: Variable size.
const MachineFunction *MF = MI->getParent()->getParent();
const char *AsmStr = MI->getOperand(0).getSymbolName();
- return getInlineAsmLength(AsmStr, *MF->getTarget().getTargetAsmInfo());
+ return getInlineAsmLength(AsmStr, *MF->getTarget().getMCAsmInfo());
}
case PPC::DBG_LABEL:
case PPC::EH_LABEL:
-//===-- PPCTargetAsmInfo.cpp - PPC asm properties ---------------*- C++ -*-===//
+//===-- PPCMCAsmInfo.cpp - PPC asm properties -------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the DarwinTargetAsmInfo properties.
+// This file contains the declarations of the DarwinMCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "PPCTargetAsmInfo.h"
+#include "PPCMCAsmInfo.h"
using namespace llvm;
-PPCDarwinTargetAsmInfo::PPCDarwinTargetAsmInfo(bool is64Bit) {
+PPCDarwinMCAsmInfo::PPCDarwinMCAsmInfo(bool is64Bit) {
PCSymbol = ".";
CommentString = ";";
ExceptionsType = ExceptionHandling::Dwarf;
AssemblerDialect = 1; // New-Style mnemonics.
}
-PPCLinuxTargetAsmInfo::PPCLinuxTargetAsmInfo(bool is64Bit) {
+PPCLinuxMCAsmInfo::PPCLinuxMCAsmInfo(bool is64Bit) {
CommentString = "#";
GlobalPrefix = "";
PrivateGlobalPrefix = ".L";
-//=====-- PPCTargetAsmInfo.h - PPC asm properties -------------*- C++ -*--====//
+//=====-- PPCMCAsmInfo.h - PPC asm properties -----------------*- C++ -*--====//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the DarwinTargetAsmInfo class.
+// This file contains the declaration of the DarwinMCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef PPCTARGETASMINFO_H
#define PPCTARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
-#include "llvm/Target/DarwinTargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfoDarwin.h"
namespace llvm {
- struct PPCDarwinTargetAsmInfo : public DarwinTargetAsmInfo {
- explicit PPCDarwinTargetAsmInfo(bool is64Bit);
+ struct PPCDarwinMCAsmInfo : public DarwinMCAsmInfo {
+ explicit PPCDarwinMCAsmInfo(bool is64Bit);
};
- struct PPCLinuxTargetAsmInfo : public TargetAsmInfo {
- explicit PPCLinuxTargetAsmInfo(bool is64Bit);
+ struct PPCLinuxMCAsmInfo : public MCAsmInfo {
+ explicit PPCLinuxMCAsmInfo(bool is64Bit);
};
} // namespace llvm
//===----------------------------------------------------------------------===//
#include "PPC.h"
-#include "PPCTargetAsmInfo.h"
+#include "PPCMCAsmInfo.h"
#include "PPCTargetMachine.h"
#include "llvm/PassManager.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Support/FormattedStream.h"
using namespace llvm;
-static const TargetAsmInfo *createTargetAsmInfo(const Target &T,
+static const MCAsmInfo *createMCAsmInfo(const Target &T,
const StringRef &TT) {
Triple TheTriple(TT);
bool isPPC64 = TheTriple.getArch() == Triple::ppc64;
if (TheTriple.getOS() == Triple::Darwin)
- return new PPCDarwinTargetAsmInfo(isPPC64);
- return new PPCLinuxTargetAsmInfo(isPPC64);
+ return new PPCDarwinMCAsmInfo(isPPC64);
+ return new PPCLinuxMCAsmInfo(isPPC64);
}
RegisterTargetMachine<PPC32TargetMachine> A(ThePPC32Target);
RegisterTargetMachine<PPC64TargetMachine> B(ThePPC64Target);
- RegisterAsmInfoFn C(ThePPC32Target, createTargetAsmInfo);
- RegisterAsmInfoFn D(ThePPC64Target, createTargetAsmInfo);
+ RegisterAsmInfoFn C(ThePPC32Target, createMCAsmInfo);
+ RegisterAsmInfoFn D(ThePPC64Target, createMCAsmInfo);
}
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetRegistry.h"
#include "llvm/ADT/Statistic.h"
unsigned BBNumber;
public:
explicit SparcAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V), BBNumber(0) {}
virtual const char *getPassName() const {
-//===-- SparcTargetAsmInfo.cpp - Sparc asm properties ---------------------===//
+//===-- SparcMCAsmInfo.cpp - Sparc asm properties -------------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the SparcTargetAsmInfo properties.
+// This file contains the declarations of the SparcMCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "SparcTargetAsmInfo.h"
+#include "SparcMCAsmInfo.h"
#include "llvm/ADT/SmallVector.h"
using namespace llvm;
-SparcELFTargetAsmInfo::SparcELFTargetAsmInfo(const Target &T,
- const StringRef &TT) {
+SparcELFMCAsmInfo::SparcELFMCAsmInfo(const Target &T, const StringRef &TT) {
Data16bitsDirective = "\t.half\t";
Data32bitsDirective = "\t.word\t";
Data64bitsDirective = 0; // .xword is only supported by V9.
-//=====-- SparcTargetAsmInfo.h - Sparc asm properties ---------*- C++ -*--====//
+//=====-- SparcMCAsmInfo.h - Sparc asm properties -------------*- C++ -*--====//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the SparcTargetAsmInfo class.
+// This file contains the declaration of the SparcMCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef SPARCTARGETASMINFO_H
#define SPARCTARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class Target;
class StringRef;
- struct SparcELFTargetAsmInfo : public TargetAsmInfo {
- explicit SparcELFTargetAsmInfo(const Target &T, const StringRef &TT);
+ struct SparcELFMCAsmInfo : public MCAsmInfo {
+ explicit SparcELFMCAsmInfo(const Target &T, const StringRef &TT);
};
} // namespace llvm
//
//===----------------------------------------------------------------------===//
-#include "SparcTargetAsmInfo.h"
+#include "SparcMCAsmInfo.h"
#include "SparcTargetMachine.h"
#include "Sparc.h"
#include "llvm/PassManager.h"
extern "C" void LLVMInitializeSparcTarget() {
// Register the target.
RegisterTargetMachine<SparcTargetMachine> X(TheSparcTarget);
- RegisterAsmInfo<SparcELFTargetAsmInfo> Y(TheSparcTarget);
+ RegisterAsmInfo<SparcELFMCAsmInfo> Y(TheSparcTarget);
}
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetRegistry.h"
class VISIBILITY_HIDDEN SystemZAsmPrinter : public AsmPrinter {
public:
SystemZAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *TAI, bool V)
+ const MCAsmInfo *TAI, bool V)
: AsmPrinter(O, TM, TAI, V) {}
virtual const char *getPassName() const {
-//===-- SystemZTargetAsmInfo.cpp - SystemZ asm properties -----------------===//
+//===-- SystemZMCAsmInfo.cpp - SystemZ asm properties ---------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the SystemZTargetAsmInfo properties.
+// This file contains the declarations of the SystemZMCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "SystemZTargetAsmInfo.h"
+#include "SystemZMCAsmInfo.h"
using namespace llvm;
-SystemZTargetAsmInfo::SystemZTargetAsmInfo(const Target &T,
- const StringRef &TT) {
+SystemZMCAsmInfo::SystemZMCAsmInfo(const Target &T, const StringRef &TT) {
AlignmentIsInBytes = true;
PrivateGlobalPrefix = ".L";
-//====-- SystemZTargetAsmInfo.h - SystemZ asm properties -------*- C++ -*--===//
+//====-- SystemZMCAsmInfo.h - SystemZ asm properties -----------*- C++ -*--===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the SystemZTargetAsmInfo class.
+// This file contains the declaration of the SystemZMCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef SystemZTARGETASMINFO_H
#define SystemZTARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class Target;
class StringRef;
- struct SystemZTargetAsmInfo : public TargetAsmInfo {
- explicit SystemZTargetAsmInfo(const Target &T, const StringRef &TT);
+ struct SystemZMCAsmInfo : public MCAsmInfo {
+ explicit SystemZMCAsmInfo(const Target &T, const StringRef &TT);
};
} // namespace llvm
//
//===----------------------------------------------------------------------===//
-#include "SystemZTargetAsmInfo.h"
+#include "SystemZMCAsmInfo.h"
#include "SystemZTargetMachine.h"
#include "SystemZ.h"
#include "llvm/PassManager.h"
extern "C" void LLVMInitializeSystemZTarget() {
// Register the target.
RegisterTargetMachine<SystemZTargetMachine> X(TheSystemZTarget);
- RegisterAsmInfo<SystemZTargetAsmInfo> Y(TheSystemZTarget);
+ RegisterAsmInfo<SystemZMCAsmInfo> Y(TheSystemZTarget);
}
/// SystemZTargetMachine ctor - Create an ILP64 architecture model
-//===-- TargetAsmInfo.cpp - Asm Info ---------------------------------------==//
+//===-- MCAsmInfo.cpp - Asm Info -------------------------------------------==//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include <cctype>
#include <cstring>
using namespace llvm;
-TargetAsmInfo::TargetAsmInfo() {
+MCAsmInfo::MCAsmInfo() {
ZeroFillDirective = 0;
NonexecutableStackDirective = 0;
NeedsSet = false;
AsmTransCBE = 0;
}
-TargetAsmInfo::~TargetAsmInfo() {
+MCAsmInfo::~MCAsmInfo() {
}
-unsigned TargetAsmInfo::getULEB128Size(unsigned Value) {
+unsigned MCAsmInfo::getULEB128Size(unsigned Value) {
unsigned Size = 0;
do {
Value >>= 7;
return Size;
}
-unsigned TargetAsmInfo::getSLEB128Size(int Value) {
+unsigned MCAsmInfo::getSLEB128Size(int Value) {
unsigned Size = 0;
int Sign = Value >> (8 * sizeof(Value) - 1);
bool IsMore;
//===----------------------------------------------------------------------===//
#include "llvm/Target/TargetInstrInfo.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Support/ErrorHandling.h"
using namespace llvm;
/// Variable-length instructions are not handled here; this function
/// may be overloaded in the target code to do that.
unsigned TargetInstrInfo::getInlineAsmLength(const char *Str,
- const TargetAsmInfo &TAI) const {
+ const MCAsmInfo &TAI) const {
// Count the number of instructions in the asm.
//
//===----------------------------------------------------------------------===//
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Support/CommandLine.h"
#include "X86COFF.h"
#include "X86MachineFunctionInfo.h"
#include "X86TargetMachine.h"
-#include "X86TargetAsmInfo.h"
+#include "X86MCAsmInfo.h"
#include "llvm/CallingConv.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Module.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Support/Mangler.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetOptions.h"
using namespace llvm;
const X86Subtarget *Subtarget;
public:
explicit X86ATTAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V) {
Subtarget = &TM.getSubtarget<X86Subtarget>();
}
#define DEBUG_TYPE "asm-printer"
#include "llvm/MC/MCInst.h"
#include "X86ATTAsmPrinter.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
using namespace llvm;
#include "X86.h"
#include "X86ATTAsmPrinter.h"
#include "X86IntelAsmPrinter.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetRegistry.h"
using namespace llvm;
///
static AsmPrinter *createX86CodePrinterPass(formatted_raw_ostream &o,
TargetMachine &tm,
- const TargetAsmInfo *tai,
+ const MCAsmInfo *tai,
bool verbose) {
- if (tm.getTargetAsmInfo()->getAssemblerDialect() == 1)
+ if (tm.getMCAsmInfo()->getAssemblerDialect() == 1)
return new X86IntelAsmPrinter(o, tm, tai, verbose);
return new X86ATTAsmPrinter(o, tm, tai, verbose);
}
#define DEBUG_TYPE "asm-printer"
#include "X86IntelAsmPrinter.h"
#include "X86InstrInfo.h"
-#include "X86TargetAsmInfo.h"
+#include "X86MCAsmInfo.h"
#include "X86.h"
#include "llvm/CallingConv.h"
#include "llvm/Constants.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/CodeGen/DwarfWriter.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Support/ErrorHandling.h"
struct VISIBILITY_HIDDEN X86IntelAsmPrinter : public AsmPrinter {
explicit X86IntelAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V) {}
virtual const char *getPassName() const {
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetOptions.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
using namespace llvm;
namespace {
const MachineFunction *MF = MI.getParent()->getParent();
const TargetInstrInfo &TII = *MF->getTarget().getInstrInfo();
FinalSize += TII.getInlineAsmLength(MI.getOperand(0).getSymbolName(),
- *MF->getTarget().getTargetAsmInfo());
+ *MF->getTarget().getMCAsmInfo());
break;
}
case TargetInstrInfo::DBG_LABEL:
-//===-- X86TargetAsmInfo.cpp - X86 asm properties ---------------*- C++ -*-===//
+//===-- X86MCAsmInfo.cpp - X86 asm properties -----------------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of the X86TargetAsmInfo properties.
+// This file contains the declarations of the X86MCAsmInfo properties.
//
//===----------------------------------------------------------------------===//
-#include "X86TargetAsmInfo.h"
+#include "X86MCAsmInfo.h"
#include "X86TargetMachine.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Support/CommandLine.h"
"{cc}", "cc",
0,0};
-X86DarwinTargetAsmInfo::X86DarwinTargetAsmInfo(const Triple &Triple) {
+X86DarwinMCAsmInfo::X86DarwinMCAsmInfo(const Triple &Triple) {
AsmTransCBE = x86_asm_table;
AssemblerDialect = AsmWriterFlavor;
AbsoluteEHSectionOffsets = false;
}
-X86ELFTargetAsmInfo::X86ELFTargetAsmInfo(const Triple &Triple) {
+X86ELFMCAsmInfo::X86ELFMCAsmInfo(const Triple &Triple) {
AsmTransCBE = x86_asm_table;
AssemblerDialect = AsmWriterFlavor;
NonexecutableStackDirective = "\t.section\t.note.GNU-stack,\"\",@progbits";
}
-X86COFFTargetAsmInfo::X86COFFTargetAsmInfo(const Triple &Triple) {
+X86COFFMCAsmInfo::X86COFFMCAsmInfo(const Triple &Triple) {
AsmTransCBE = x86_asm_table;
AssemblerDialect = AsmWriterFlavor;
}
-X86WinTargetAsmInfo::X86WinTargetAsmInfo(const Triple &Triple) {
+X86WinMCAsmInfo::X86WinMCAsmInfo(const Triple &Triple) {
AsmTransCBE = x86_asm_table;
AssemblerDialect = AsmWriterFlavor;
--- /dev/null
+//=====-- X86MCAsmInfo.h - X86 asm properties -----------------*- C++ -*--====//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the declaration of the X86MCAsmInfo class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef X86TARGETASMINFO_H
+#define X86TARGETASMINFO_H
+
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCAsmInfoCOFF.h"
+#include "llvm/MC/MCAsmInfoDarwin.h"
+
+namespace llvm {
+ class Triple;
+
+ struct X86DarwinMCAsmInfo : public DarwinMCAsmInfo {
+ explicit X86DarwinMCAsmInfo(const Triple &Triple);
+ };
+
+ struct X86ELFMCAsmInfo : public MCAsmInfo {
+ explicit X86ELFMCAsmInfo(const Triple &Triple);
+ };
+
+ struct X86COFFMCAsmInfo : public COFFMCAsmInfo {
+ explicit X86COFFMCAsmInfo(const Triple &Triple);
+ };
+
+ struct X86WinMCAsmInfo : public MCAsmInfo {
+ explicit X86WinMCAsmInfo(const Triple &Triple);
+ };
+
+} // namespace llvm
+
+#endif
#include "llvm/CodeGen/MachineLocation.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetFrameInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetMachine.h"
+++ /dev/null
-//=====-- X86TargetAsmInfo.h - X86 asm properties -------------*- C++ -*--====//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the declaration of the X86TargetAsmInfo class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef X86TARGETASMINFO_H
-#define X86TARGETASMINFO_H
-
-#include "llvm/Target/TargetAsmInfo.h"
-#include "llvm/Target/COFFTargetAsmInfo.h"
-#include "llvm/Target/DarwinTargetAsmInfo.h"
-
-namespace llvm {
- class Triple;
-
- struct X86DarwinTargetAsmInfo : public DarwinTargetAsmInfo {
- explicit X86DarwinTargetAsmInfo(const Triple &Triple);
- };
-
- struct X86ELFTargetAsmInfo : public TargetAsmInfo {
- explicit X86ELFTargetAsmInfo(const Triple &Triple);
- };
-
- struct X86COFFTargetAsmInfo : public COFFTargetAsmInfo {
- explicit X86COFFTargetAsmInfo(const Triple &Triple);
- };
-
- struct X86WinTargetAsmInfo : public TargetAsmInfo {
- explicit X86WinTargetAsmInfo(const Triple &Triple);
- };
-
-} // namespace llvm
-
-#endif
//
//===----------------------------------------------------------------------===//
-#include "X86TargetAsmInfo.h"
+#include "X86MCAsmInfo.h"
#include "X86TargetMachine.h"
#include "X86.h"
#include "llvm/PassManager.h"
#include "llvm/Target/TargetRegistry.h"
using namespace llvm;
-static const TargetAsmInfo *createTargetAsmInfo(const Target &T,
+static const MCAsmInfo *createMCAsmInfo(const Target &T,
const StringRef &TT) {
Triple TheTriple(TT);
switch (TheTriple.getOS()) {
case Triple::Darwin:
- return new X86DarwinTargetAsmInfo(TheTriple);
+ return new X86DarwinMCAsmInfo(TheTriple);
case Triple::MinGW32:
case Triple::MinGW64:
case Triple::Cygwin:
- return new X86COFFTargetAsmInfo(TheTriple);
+ return new X86COFFMCAsmInfo(TheTriple);
case Triple::Win32:
- return new X86WinTargetAsmInfo(TheTriple);
+ return new X86WinMCAsmInfo(TheTriple);
default:
- return new X86ELFTargetAsmInfo(TheTriple);
+ return new X86ELFMCAsmInfo(TheTriple);
}
}
RegisterTargetMachine<X86_64TargetMachine> Y(TheX86_64Target);
// Register the target asm info.
- RegisterAsmInfoFn A(TheX86_32Target, createTargetAsmInfo);
- RegisterAsmInfoFn B(TheX86_64Target, createTargetAsmInfo);
+ RegisterAsmInfoFn A(TheX86_32Target, createMCAsmInfo);
+ RegisterAsmInfoFn B(TheX86_64Target, createMCAsmInfo);
}
#include "XCore.h"
#include "XCoreInstrInfo.h"
#include "XCoreSubtarget.h"
-#include "XCoreTargetAsmInfo.h"
+#include "XCoreMCAsmInfo.h"
#include "XCoreTargetMachine.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
const XCoreSubtarget &Subtarget;
public:
explicit XCoreAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
- const TargetAsmInfo *T, bool V)
+ const MCAsmInfo *T, bool V)
: AsmPrinter(O, TM, T, V), DW(0),
Subtarget(TM.getSubtarget<XCoreSubtarget>()) {}
/// PrintTargetSpecificSectionFlags - This handles the XCore-specific cp/dp
/// section flags.
-void MCSectionXCore::PrintTargetSpecificSectionFlags(const TargetAsmInfo &TAI,
+void MCSectionXCore::PrintTargetSpecificSectionFlags(const MCAsmInfo &TAI,
raw_ostream &OS) const {
if (getFlags() & MCSectionXCore::SHF_CP_SECTION)
OS << 'c';
/// PrintTargetSpecificSectionFlags - This handles the XCore-specific cp/dp
/// section flags.
- virtual void PrintTargetSpecificSectionFlags(const TargetAsmInfo &TAI,
+ virtual void PrintTargetSpecificSectionFlags(const MCAsmInfo &TAI,
raw_ostream &OS) const;
};
-//===-- XCoreTargetAsmInfo.cpp - XCore asm properties ---------------------===//
+//===-- XCoreMCAsmInfo.cpp - XCore asm properties -------------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#include "XCoreTargetAsmInfo.h"
+#include "XCoreMCAsmInfo.h"
using namespace llvm;
-XCoreTargetAsmInfo::XCoreTargetAsmInfo(const Target &T, const StringRef &TT) {
+XCoreMCAsmInfo::XCoreMCAsmInfo(const Target &T, const StringRef &TT) {
SupportsDebugInformation = true;
Data16bitsDirective = "\t.short\t";
Data32bitsDirective = "\t.long\t";
-//=====-- XCoreTargetAsmInfo.h - XCore asm properties ---------*- C++ -*--====//
+//=====-- XCoreMCAsmInfo.h - XCore asm properties -------------*- C++ -*--====//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the declaration of the XCoreTargetAsmInfo class.
+// This file contains the declaration of the XCoreMCAsmInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef XCORETARGETASMINFO_H
#define XCORETARGETASMINFO_H
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class Target;
class StringRef;
- class XCoreTargetAsmInfo : public TargetAsmInfo {
+ class XCoreMCAsmInfo : public MCAsmInfo {
public:
- explicit XCoreTargetAsmInfo(const Target &T, const StringRef &TT);
+ explicit XCoreMCAsmInfo(const Target &T, const StringRef &TT);
};
} // namespace llvm
//
//===----------------------------------------------------------------------===//
-#include "XCoreTargetAsmInfo.h"
+#include "XCoreMCAsmInfo.h"
#include "XCoreTargetMachine.h"
#include "XCore.h"
#include "llvm/Module.h"
// Force static initialization.
extern "C" void LLVMInitializeXCoreTarget() {
RegisterTargetMachine<XCoreTargetMachine> X(TheXCoreTarget);
- RegisterAsmInfo<XCoreTargetAsmInfo> Y(TheXCoreTarget);
+ RegisterAsmInfo<XCoreMCAsmInfo> Y(TheXCoreTarget);
}
OwningPtr<MCStreamer> Str;
if (FileType == OFT_AssemblyFile) {
- const TargetAsmInfo *TAI = TheTarget->createAsmInfo(TripleName);
+ const MCAsmInfo *TAI = TheTarget->createAsmInfo(TripleName);
assert(TAI && "Unable to create target asm info!");
AP.reset(TheTarget->createAsmPrinter(*Out, *TM, TAI, true));
#include "llvm/System/Signals.h"
#include "llvm/Target/SubtargetFeature.h"
#include "llvm/Target/TargetOptions.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetRegistry.h"
// mark which symbols can not be internalized
if ( !_mustPreserveSymbols.empty() ) {
Mangler mangler(*mergedModule,
- _target->getTargetAsmInfo()->getGlobalPrefix());
+ _target->getMCAsmInfo()->getGlobalPrefix());
std::vector<const char*> mustPreserveList;
for (Module::iterator f = mergedModule->begin(),
e = mergedModule->end(); f != e; ++f) {
Module* mergedModule = _linker.getModule();
// If target supports exception handling then enable it now.
- switch (_target->getTargetAsmInfo()->getExceptionHandlingType()) {
+ switch (_target->getMCAsmInfo()->getExceptionHandlingType()) {
case ExceptionHandling::Dwarf:
llvm::DwarfExceptionHandling = true;
break;
#include "llvm/System/Path.h"
#include "llvm/System/Process.h"
#include "llvm/Target/SubtargetFeature.h"
-#include "llvm/Target/TargetAsmInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetRegistry.h"
#include "llvm/Target/TargetSelect.h"
_symbolsParsed = true;
// Use mangler to add GlobalPrefix to names to match linker names.
- Mangler mangler(*_module, _target->getTargetAsmInfo()->getGlobalPrefix());
+ Mangler mangler(*_module, _target->getMCAsmInfo()->getGlobalPrefix());
// add chars used in ObjC method names so method names aren't mangled
mangler.markCharAcceptable('[');
mangler.markCharAcceptable(']');
OSDN Git Service
