6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-21 02:29:22 +00:00
Code Issues Projects Releases Wiki Activity

Revert my previous patch to make the valgrind bots happy.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@121461 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola 2010-12-10 04:01:09 +00:00
parent 51c06bf6ad
commit f7fd4aa261
32 changed files with 176 additions and 550 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/llvm/CodeGen/MachineModuleInfo.h
View File

@ -170,8 +170,7 @@ public:
VariableDbgInfoMapTy VariableDbgInfo;
MachineModuleInfo(); // DUMMY CONSTRUCTOR, DO NOT CALL.
// Real constructor.
MachineModuleInfo(const MCAsmInfo &MAI, const TargetAsmInfo *TAI);
MachineModuleInfo(const MCAsmInfo &MAI); // Real constructor.
~MachineModuleInfo();
bool doInitialization();

7
include/llvm/MC/MCContext.h
View File

@ -29,7 +29,6 @@ namespace llvm {
class MCLineSection;
class StringRef;
class Twine;
class TargetAsmInfo;
class MCSectionMachO;
class MCSectionELF;
@ -43,8 +42,6 @@ namespace llvm {
/// The MCAsmInfo for this target.
const MCAsmInfo &MAI;
const TargetAsmInfo *TAI;
/// Symbols - Bindings of names to symbols.
StringMap<MCSymbol*> Symbols;
@ -102,13 +99,11 @@ namespace llvm {
MCSymbol *CreateSymbol(StringRef Name);
public:
explicit MCContext(const MCAsmInfo &MAI, const TargetAsmInfo *TAI);
explicit MCContext(const MCAsmInfo &MAI);
~MCContext();
const MCAsmInfo &getAsmInfo() const { return MAI; }
const TargetAsmInfo &getTargetAsmInfo() const { return *TAI; }
/// @name Symbol Management
/// @{

18
include/llvm/MC/MCDwarf.h
View File

@ -22,7 +22,6 @@
#include <vector>
namespace llvm {
class MachineMove;
class MCContext;
class MCSection;
class MCSectionData;
@ -209,7 +208,7 @@ namespace llvm {
//
// This emits the Dwarf file and the line tables.
//
static void Emit(MCStreamer *MCOS);
static void Emit(MCStreamer *MCOS, const MCSection *DwarfLineSection);
};
class MCDwarfLineAddr {
@ -225,21 +224,6 @@ namespace llvm {
static void Write(MCObjectWriter *OW,
int64_t LineDelta, uint64_t AddrDelta);
};
struct MCDwarfFrameInfo {
MCSymbol *Begin;
MCSymbol *End;
const MCSymbol *Personality;
const MCSymbol *Lsda;
};
class MCDwarfFrameEmitter {
public:
//
// This emits the frame info section.
//
static void Emit(MCStreamer &streamer);
};
} // end namespace llvm
#endif

3
include/llvm/MC/MCObjectStreamer.h
View File

@ -59,8 +59,7 @@ public:
/// @{
virtual void EmitLabel(MCSymbol *Symbol);
virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
bool isPCRel, unsigned AddrSpace);
virtual void EmitValue(const MCExpr *Value, unsigned Size,unsigned AddrSpace);
virtual void EmitULEB128Value(const MCExpr *Value, unsigned AddrSpace = 0);
virtual void EmitSLEB128Value(const MCExpr *Value, unsigned AddrSpace = 0);
virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);

39
include/llvm/MC/MCStreamer.h
View File

@ -16,7 +16,6 @@
#include "llvm/Support/DataTypes.h"
#include "llvm/MC/MCDirectives.h"
#include "llvm/MC/MCDwarf.h"
namespace llvm {
class MCAsmInfo;
@ -49,9 +48,6 @@ namespace llvm {
MCStreamer(const MCStreamer&); // DO NOT IMPLEMENT
MCStreamer &operator=(const MCStreamer&); // DO NOT IMPLEMENT
void EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
bool isPCRel, unsigned AddrSpace);
protected:
MCStreamer(MCContext &Ctx);
@ -63,23 +59,11 @@ namespace llvm {
/// is kept up to date by SwitchSection.
const MCSection *PrevSection;
std::vector<MCDwarfFrameInfo> FrameInfos;
MCDwarfFrameInfo *getCurrentFrameInfo();
void EnsureValidFrame();
public:
virtual ~MCStreamer();
MCContext &getContext() const { return Context; }
unsigned getNumFrameInfos() {
return FrameInfos.size();
}
const MCDwarfFrameInfo &getFrameInfo(unsigned i) {
return FrameInfos[i];
}
/// @name Assembly File Formatting.
/// @{
@ -257,13 +241,8 @@ namespace llvm {
/// @param Value - The value to emit.
/// @param Size - The size of the integer (in bytes) to emit. This must
/// match a native machine width.
virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
bool isPCRel, unsigned AddrSpace) = 0;
void EmitValue(const MCExpr *Value, unsigned Size, unsigned AddrSpace = 0);
void EmitPCRelValue(const MCExpr *Value, unsigned Size,
unsigned AddrSpace = 0);
virtual void EmitValue(const MCExpr *Value, unsigned Size,
unsigned AddrSpace = 0) = 0;
/// EmitIntValue - Special case of EmitValue that avoids the client having
/// to pass in a MCExpr for constant integers.
@ -296,9 +275,6 @@ namespace llvm {
void EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
unsigned AddrSpace = 0);
void EmitPCRelSymbolValue(const MCSymbol *Sym, unsigned Size,
unsigned AddrSpace = 0);
/// EmitGPRel32Value - Emit the expression @p Value into the output as a
/// gprel32 (32-bit GP relative) value.
///
@ -429,12 +405,19 @@ namespace llvm {
/// \param ShowInst - Whether to show the MCInst representation inline with
/// the assembly.
MCStreamer *createAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
bool isVerboseAsm,
bool useLoc,
bool isLittleEndian, bool isVerboseAsm,
MCInstPrinter *InstPrint = 0,
MCCodeEmitter *CE = 0,
bool ShowInst = false);
MCStreamer *createAsmStreamerNoLoc(MCContext &Ctx, formatted_raw_ostream &OS,
bool isLittleEndian, bool isVerboseAsm,
const TargetLoweringObjectFile *TLOF,
int PointerSize,
MCInstPrinter *InstPrint = 0,
MCCodeEmitter *CE = 0,
bool ShowInst = false);
/// createMachOStreamer - Create a machine code streamer which will generate
/// Mach-O format object files.
///

4
include/llvm/Target/TargetAsmBackend.h
View File

@ -21,6 +21,7 @@ class MCObjectWriter;
class MCSection;
template<typename T>
class SmallVectorImpl;
class Target;
class raw_ostream;
/// TargetAsmBackend - Generic interface to target specific assembler backends.
@ -80,6 +81,9 @@ public:
return true;
}
/// getPointerSize - Get the pointer size in bytes.
virtual unsigned getPointerSize() const = 0;
/// ApplyFixup - Apply the \arg Value for given \arg Fixup into the provided
/// data fragment, at the offset specified by the fixup and following the
/// fixup kind as appropriate.

75
include/llvm/Target/TargetAsmInfo.h
View File

@ -1,75 +0,0 @@
//===-- llvm/Target/TargetAsmInfo.h -----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Interface to provide the information necessary for producing assembly files.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TARGET_TARGETASMINFO_H
#define LLVM_TARGET_TARGETASMINFO_H
#include "llvm/CodeGen/MachineLocation.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetFrameInfo.h"
#include "llvm/Target/TargetRegisterInfo.h"
namespace llvm {
class MCSection;
class MCContext;
class TargetMachine;
class TargetLoweringObjectFile;
class TargetAsmInfo {
unsigned PointerSize;
bool IsLittleEndian;
TargetFrameInfo::StackDirection StackDir;
const TargetRegisterInfo *TRI;
std::vector<MachineMove> InitialFrameState;
const TargetLoweringObjectFile *TLOF;
public:
explicit TargetAsmInfo(const TargetMachine &TM);
/// getPointerSize - Get the pointer size in bytes.
unsigned getPointerSize() const {
return PointerSize;
}
/// islittleendian - True if the target is little endian.
bool isLittleEndian() const {
return IsLittleEndian;
}
TargetFrameInfo::StackDirection getStackGrowthDirection() const {
return StackDir;
}
const MCSection *getDwarfLineSection() const {
return TLOF->getDwarfLineSection();
}
const MCSection *getEHFrameSection() const {
return TLOF->getEHFrameSection();
}
unsigned getDwarfRARegNum(bool isEH) const {
return TRI->getDwarfRegNum(TRI->getRARegister(), isEH);
}
const std::vector<MachineMove> &getInitialFrameState() const {
return InitialFrameState;
}
int getDwarfRegNum(unsigned RegNum, bool isEH) const {
return TRI->getDwarfRegNum(RegNum, isEH);
}
};
}
#endif

9
include/llvm/Target/TargetRegistry.h
View File

@ -42,8 +42,7 @@ namespace llvm {
class formatted_raw_ostream;
MCStreamer *createAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
bool isVerboseAsm,
bool useLoc,
bool isLittleEndian, bool isVerboseAsm,
MCInstPrinter *InstPrint,
MCCodeEmitter *CE,
bool ShowInst);
@ -91,8 +90,8 @@ namespace llvm {
bool RelaxAll);
typedef MCStreamer *(*AsmStreamerCtorTy)(MCContext &Ctx,
formatted_raw_ostream &OS,
bool isLittleEndian,
bool isVerboseAsm,
bool useLoc,
MCInstPrinter *InstPrint,
MCCodeEmitter *CE,
bool ShowInst);
@ -319,13 +318,13 @@ namespace llvm {
/// createAsmStreamer - Create a target specific MCStreamer.
MCStreamer *createAsmStreamer(MCContext &Ctx,
formatted_raw_ostream &OS,
bool isLittleEndian,
bool isVerboseAsm,
bool useLoc,
MCInstPrinter *InstPrint,
MCCodeEmitter *CE,
bool ShowInst) const {
// AsmStreamerCtorFn is default to llvm::createAsmStreamer
return AsmStreamerCtorFn(Ctx, OS, isVerboseAsm, useLoc,
return AsmStreamerCtorFn(Ctx, OS, isLittleEndian, isVerboseAsm,
InstPrint, CE, ShowInst);
}

3
lib/CodeGen/ELFWriter.cpp
View File

@ -45,7 +45,6 @@
#include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/Mangler.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetELFWriterInfo.h"
#include "llvm/Target/TargetLowering.h"
@ -65,7 +64,7 @@ char ELFWriter::ID = 0;
ELFWriter::ELFWriter(raw_ostream &o, TargetMachine &tm)
: MachineFunctionPass(ID), O(o), TM(tm),
OutContext(*new MCContext(*TM.getMCAsmInfo(), new TargetAsmInfo(tm))),
OutContext(*new MCContext(*TM.getMCAsmInfo())),
TLOF(TM.getTargetLowering()->getObjFileLowering()),
is64Bit(TM.getTargetData()->getPointerSizeInBits() == 64),
isLittleEndian(TM.getTargetData()->isLittleEndian()),

31
lib/CodeGen/LLVMTargetMachine.cpp
View File

@ -24,7 +24,6 @@
#include "llvm/Target/TargetOptions.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetRegistry.h"
#include "llvm/Transforms/Scalar.h"
@ -146,12 +145,27 @@ bool LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
if (ShowMCEncoding)
MCE = getTarget().createCodeEmitter(*this, *Context);
MCStreamer *S = getTarget().createAsmStreamer(*Context, Out,
getVerboseAsm(),
hasMCUseLoc(),
InstPrinter,
MCE,
ShowMCInst);
const TargetLoweringObjectFile &TLOF =
getTargetLowering()->getObjFileLowering();
int PointerSize = getTargetData()->getPointerSize();
MCStreamer *S;
if (hasMCUseLoc())
S = getTarget().createAsmStreamer(*Context, Out,
getTargetData()->isLittleEndian(),
getVerboseAsm(),
InstPrinter,
MCE,
ShowMCInst);
else
S = createAsmStreamerNoLoc(*Context, Out,
getTargetData()->isLittleEndian(),
getVerboseAsm(),
&TLOF,
PointerSize,
InstPrinter,
MCE,
ShowMCInst);
AsmStreamer.reset(S);
break;
}
@ -330,8 +344,7 @@ bool LLVMTargetMachine::addCommonCodeGenPasses(PassManagerBase &PM,
// Install a MachineModuleInfo class, which is an immutable pass that holds
// all the per-module stuff we're generating, including MCContext.
TargetAsmInfo *TAI = new TargetAsmInfo(*this);
MachineModuleInfo *MMI = new MachineModuleInfo(*getMCAsmInfo(), TAI);
MachineModuleInfo *MMI = new MachineModuleInfo(*getMCAsmInfo());
PM.add(MMI);
OutContext = &MMI->getContext(); // Return the MCContext specifically by-ref.

7
lib/CodeGen/MachineModuleInfo.cpp
View File

@ -253,9 +253,8 @@ void MMIAddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {
//===----------------------------------------------------------------------===//
MachineModuleInfo::MachineModuleInfo(const MCAsmInfo &MAI,
const TargetAsmInfo *TAI)
: ImmutablePass(ID), Context(MAI, TAI),
MachineModuleInfo::MachineModuleInfo(const MCAsmInfo &MAI)
: ImmutablePass(ID), Context(MAI),
ObjFileMMI(0),
CurCallSite(0), CallsEHReturn(0), CallsUnwindInit(0), DbgInfoAvailable(false),
CallsExternalVAFunctionWithFloatingPointArguments(false) {
@ -267,7 +266,7 @@ MachineModuleInfo::MachineModuleInfo(const MCAsmInfo &MAI,
}
MachineModuleInfo::MachineModuleInfo()
: ImmutablePass(ID), Context(*(MCAsmInfo*)0, NULL) {
: ImmutablePass(ID), Context(*(MCAsmInfo*)0) {
assert(0 && "This MachineModuleInfo constructor should never be called, MMI "
"should always be explicitly constructed by LLVMTargetMachine");
abort();

2
lib/CodeGen/TargetLoweringObjectFileImpl.cpp
View File

@ -135,7 +135,7 @@ void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
SectionKind::getReadOnly());
EHFrameSection =
getContext().getELFSection(".eh_frame", MCSectionELF::SHT_PROGBITS,
MCSectionELF::SHF_ALLOC,
MCSectionELF::SHF_ALLOC |MCSectionELF::SHF_WRITE,
SectionKind::getDataRel());
// Debug Info Sections.

63
lib/MC/MCAsmStreamer.cpp
View File

@ -24,7 +24,6 @@
#include "llvm/Support/Format.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetAsmInfo.h"
using namespace llvm;
namespace {
@ -38,26 +37,32 @@ class MCAsmStreamer : public MCStreamer {
SmallString<128> CommentToEmit;
raw_svector_ostream CommentStream;
const TargetLoweringObjectFile *TLOF;
int PointerSize;
unsigned IsLittleEndian : 1;
unsigned IsVerboseAsm : 1;
unsigned ShowInst : 1;
unsigned UseLoc : 1;
bool needsSet(const MCExpr *Value);
public:
MCAsmStreamer(MCContext &Context, formatted_raw_ostream &os,
bool isVerboseAsm,
bool useLoc,
bool isLittleEndian, bool isVerboseAsm,
const TargetLoweringObjectFile *tlof, int pointerSize,
MCInstPrinter *printer, MCCodeEmitter *emitter, bool showInst)
: MCStreamer(Context), OS(os), MAI(Context.getAsmInfo()),
InstPrinter(printer), Emitter(emitter), CommentStream(CommentToEmit),
IsVerboseAsm(isVerboseAsm),
ShowInst(showInst), UseLoc(useLoc) {
TLOF(tlof), PointerSize(pointerSize),
IsLittleEndian(isLittleEndian), IsVerboseAsm(isVerboseAsm),
ShowInst(showInst) {
if (InstPrinter && IsVerboseAsm)
InstPrinter->setCommentStream(CommentStream);
}
~MCAsmStreamer() {}
bool isLittleEndian() const { return IsLittleEndian; }
inline void EmitEOL() {
// If we don't have any comments, just emit a \n.
if (!IsVerboseAsm) {
@ -147,8 +152,7 @@ public:
virtual void EmitBytes(StringRef Data, unsigned AddrSpace);
virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
bool isPCRel, unsigned AddrSpace);
virtual void EmitValue(const MCExpr *Value, unsigned Size,unsigned AddrSpace);
virtual void EmitIntValue(uint64_t Value, unsigned Size,
unsigned AddrSpace = 0);
@ -303,8 +307,7 @@ void MCAsmStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
void MCAsmStreamer::EmitDwarfAdvanceLineAddr(int64_t LineDelta,
const MCSymbol *LastLabel,
const MCSymbol *Label) {
EmitDwarfSetLineAddr(LineDelta, Label,
getContext().getTargetAsmInfo().getPointerSize());
EmitDwarfSetLineAddr(LineDelta, Label, PointerSize);
}
void MCAsmStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
@ -509,10 +512,9 @@ void MCAsmStreamer::EmitIntValue(uint64_t Value, unsigned Size,
EmitValue(MCConstantExpr::Create(Value, getContext()), Size, AddrSpace);
}
void MCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
bool isPCRel, unsigned AddrSpace) {
void MCAsmStreamer::EmitValue(const MCExpr *Value, unsigned Size,
unsigned AddrSpace) {
assert(CurSection && "Cannot emit contents before setting section!");
assert(!isPCRel && "Cannot emit pc relative relocations!");
const char *Directive = 0;
switch (Size) {
default: break;
@ -526,7 +528,7 @@ void MCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
int64_t IntValue;
if (!Value->EvaluateAsAbsolute(IntValue))
report_fatal_error("Don't know how to emit this value.");
if (getContext().getTargetAsmInfo().isLittleEndian()) {
if (isLittleEndian()) {
EmitIntValue((uint32_t)(IntValue >> 0 ), 4, AddrSpace);
EmitIntValue((uint32_t)(IntValue >> 32), 4, AddrSpace);
} else {
@ -660,7 +662,7 @@ void MCAsmStreamer::EmitFileDirective(StringRef Filename) {
}
bool MCAsmStreamer::EmitDwarfFileDirective(unsigned FileNo, StringRef Filename){
if (UseLoc) {
if (!TLOF) {
OS << "\t.file\t" << FileNo << ' ';
PrintQuotedString(Filename, OS);
EmitEOL();
@ -674,7 +676,7 @@ void MCAsmStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
unsigned Discriminator) {
this->MCStreamer::EmitDwarfLocDirective(FileNo, Line, Column, Flags,
Isa, Discriminator);
if (!UseLoc)
if (TLOF)
return;
OS << "\t.loc\t" << FileNo << " " << Line << " " << Column;
@ -827,7 +829,7 @@ void MCAsmStreamer::AddEncodingComment(const MCInst &Inst) {
unsigned Bit = (Code[i] >> j) & 1;
unsigned FixupBit;
if (getContext().getTargetAsmInfo().isLittleEndian())
if (IsLittleEndian)
FixupBit = i * 8 + j;
else
FixupBit = i * 8 + (7-j);
@ -853,7 +855,7 @@ void MCAsmStreamer::AddEncodingComment(const MCInst &Inst) {
void MCAsmStreamer::EmitInstruction(const MCInst &Inst) {
assert(CurSection && "Cannot emit contents before setting section!");
if (!UseLoc)
if (TLOF)
MCLineEntry::Make(this, getCurrentSection());
// Show the encoding in a comment if we have a code emitter.
@ -886,15 +888,28 @@ void MCAsmStreamer::EmitRawText(StringRef String) {
void MCAsmStreamer::Finish() {
// Dump out the dwarf file & directory tables and line tables.
if (getContext().hasDwarfFiles() && !UseLoc)
MCDwarfFileTable::Emit(this);
if (getContext().hasDwarfFiles() && TLOF)
MCDwarfFileTable::Emit(this, TLOF->getDwarfLineSection());
}
MCStreamer *llvm::createAsmStreamer(MCContext &Context,
formatted_raw_ostream &OS,
bool isVerboseAsm, bool useLoc,
MCInstPrinter *IP,
bool isLittleEndian,
bool isVerboseAsm, MCInstPrinter *IP,
MCCodeEmitter *CE, bool ShowInst) {
return new MCAsmStreamer(Context, OS, isVerboseAsm, useLoc,
IP, CE, ShowInst);
return new MCAsmStreamer(Context, OS, isLittleEndian, isVerboseAsm,
NULL, 0, IP, CE, ShowInst);
}
MCStreamer *llvm::createAsmStreamerNoLoc(MCContext &Context,
formatted_raw_ostream &OS,
bool isLittleEndian,
bool isVerboseAsm,
const TargetLoweringObjectFile *TLOF,
int PointerSize,
MCInstPrinter *IP,
MCCodeEmitter *CE, bool ShowInst) {
return new MCAsmStreamer(Context, OS, isLittleEndian, isVerboseAsm,
TLOF, PointerSize, IP, CE, ShowInst);
}

5
lib/MC/MCContext.cpp
View File

@ -24,9 +24,8 @@ typedef StringMap<const MCSectionELF*> ELFUniqueMapTy;
typedef StringMap<const MCSectionCOFF*> COFFUniqueMapTy;
MCContext::MCContext(const MCAsmInfo &mai, const TargetAsmInfo *tai) :
MAI(mai), TAI(tai), NextUniqueID(0),
CurrentDwarfLoc(0,0,0,DWARF2_FLAG_IS_STMT,0,0) {
MCContext::MCContext(const MCAsmInfo &mai) : MAI(mai), NextUniqueID(0),
CurrentDwarfLoc(0,0,0,DWARF2_FLAG_IS_STMT,0,0) {
MachOUniquingMap = 0;
ELFUniquingMap = 0;
COFFUniquingMap = 0;

2
lib/MC/MCDisassembler/EDDisassembler.cpp
View File

@ -354,7 +354,7 @@ int EDDisassembler::parseInst(SmallVectorImpl<MCParsedAsmOperand*> &operands,
SourceMgr sourceMgr;
sourceMgr.AddNewSourceBuffer(buf, SMLoc()); // ownership of buf handed over
MCContext context(*AsmInfo, NULL);
MCContext context(*AsmInfo);
OwningPtr<MCStreamer> streamer(createNullStreamer(context));
OwningPtr<MCAsmParser> genericParser(createMCAsmParser(*Tgt, sourceMgr,
context, *streamer,

210
lib/MC/MCDwarf.cpp
View File

@ -19,7 +19,6 @@
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetAsmBackend.h"
#include "llvm/Target/TargetAsmInfo.h"
using namespace llvm;
// Given a special op, return the address skip amount (in units of
@ -126,7 +125,8 @@ static inline const MCExpr *MakeStartMinusEndExpr(const MCStreamer &MCOS,
//
static inline void EmitDwarfLineTable(MCStreamer *MCOS,
const MCSection *Section,
const MCLineSection *LineSection) {
const MCLineSection *LineSection,
const MCSection *DwarfLineSection) {
unsigned FileNum = 1;
unsigned LastLine = 1;
unsigned Column = 0;
@ -185,15 +185,13 @@ static inline void EmitDwarfLineTable(MCStreamer *MCOS,
// Switch to the section to be able to create a symbol at its end.
MCOS->SwitchSection(Section);
MCContext &context = MCOS->getContext();
// Create a symbol at the end of the section.
MCSymbol *SectionEnd = context.CreateTempSymbol();
MCSymbol *SectionEnd = MCOS->getContext().CreateTempSymbol();
// Set the value of the symbol, as we are at the end of the section.
MCOS->EmitLabel(SectionEnd);
// Switch back the the dwarf line section.
MCOS->SwitchSection(context.getTargetAsmInfo().getDwarfLineSection());
MCOS->SwitchSection(DwarfLineSection);
MCOS->EmitDwarfAdvanceLineAddr(INT64_MAX, LastLabel, SectionEnd);
}
@ -201,18 +199,18 @@ static inline void EmitDwarfLineTable(MCStreamer *MCOS,
//
// This emits the Dwarf file and the line tables.
//
void MCDwarfFileTable::Emit(MCStreamer *MCOS) {
MCContext &context = MCOS->getContext();
void MCDwarfFileTable::Emit(MCStreamer *MCOS,
const MCSection *DwarfLineSection) {
// Switch to the section where the table will be emitted into.
MCOS->SwitchSection(context.getTargetAsmInfo().getDwarfLineSection());
MCOS->SwitchSection(DwarfLineSection);
// Create a symbol at the beginning of this section.
MCSymbol *LineStartSym = context.CreateTempSymbol();
MCSymbol *LineStartSym = MCOS->getContext().CreateTempSymbol();
// Set the value of the symbol, as we are at the start of the section.
MCOS->EmitLabel(LineStartSym);
// Create a symbol for the end of the section (to be set when we get there).
MCSymbol *LineEndSym = context.CreateTempSymbol();
MCSymbol *LineEndSym = MCOS->getContext().CreateTempSymbol();
// The first 4 bytes is the total length of the information for this
// compilation unit (not including these 4 bytes for the length).
@ -223,7 +221,7 @@ void MCDwarfFileTable::Emit(MCStreamer *MCOS) {
MCOS->EmitIntValue(2, 2);
// Create a symbol for the end of the prologue (to be set when we get there).
MCSymbol *ProEndSym = context.CreateTempSymbol(); // Lprologue_end
MCSymbol *ProEndSym = MCOS->getContext().CreateTempSymbol(); // Lprologue_end
// Length of the prologue, is the next 4 bytes. Which is the start of the
// section to the end of the prologue. Not including the 4 bytes for the
@ -258,7 +256,7 @@ void MCDwarfFileTable::Emit(MCStreamer *MCOS) {
// First the directory table.
const std::vector<StringRef> &MCDwarfDirs =
context.getMCDwarfDirs();
MCOS->getContext().getMCDwarfDirs();
for (unsigned i = 0; i < MCDwarfDirs.size(); i++) {
MCOS->EmitBytes(MCDwarfDirs[i], 0); // the DirectoryName
MCOS->EmitBytes(StringRef("\0", 1), 0); // the null term. of the string
@ -292,7 +290,7 @@ void MCDwarfFileTable::Emit(MCStreamer *MCOS) {
++it) {
const MCSection *Sec = *it;
const MCLineSection *Line = MCLineSections.lookup(Sec);
EmitDwarfLineTable(MCOS, Sec, Line);
EmitDwarfLineTable(MCOS, Sec, Line, DwarfLineSection);
// Now delete the MCLineSections that were created in MCLineEntry::Make()
// and used to emit the line table.
@ -427,187 +425,3 @@ void MCDwarfFile::dump() const {
print(dbgs());
}
static int getDataAlignmentFactor(MCStreamer &streamer) {
MCContext &context = streamer.getContext();
const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
int size = asmInfo.getPointerSize();
if (asmInfo.getStackGrowthDirection() == TargetFrameInfo::StackGrowsUp)
return size;
else
return -size;
}
/// EmitFrameMoves - Emit frame instructions to describe the layout of the
/// frame.
static void EmitFrameMoves(MCStreamer &streamer,
const std::vector<MachineMove> &Moves,
MCSymbol *BaseLabel, bool isEH) {
MCContext &context = streamer.getContext();
const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
int dataAlignmentFactor = getDataAlignmentFactor(streamer);
for (unsigned i = 0, N = Moves.size(); i < N; ++i) {
const MachineMove &Move = Moves[i];
MCSymbol *Label = Move.getLabel();
// Throw out move if the label is invalid.
if (Label && !Label->isDefined()) continue; // Not emitted, in dead code.
const MachineLocation &Dst = Move.getDestination();
const MachineLocation &Src = Move.getSource();
// Advance row if new location.
if (BaseLabel && Label) {
MCSymbol *ThisSym = Label;
if (ThisSym != BaseLabel) {
streamer.EmitIntValue(dwarf::DW_CFA_advance_loc4, 1);
const MCExpr *Length = MakeStartMinusEndExpr(streamer, *BaseLabel,
*ThisSym, 4);
streamer.EmitValue(Length, 4);
BaseLabel = ThisSym;
}
}
// If advancing cfa.
if (Dst.isReg() && Dst.getReg() == MachineLocation::VirtualFP) {
assert(!Src.isReg() && "Machine move not supported yet.");
if (Src.getReg() == MachineLocation::VirtualFP) {
streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_offset, 1);
} else {
streamer.EmitIntValue(dwarf::DW_CFA_def_cfa, 1);
streamer.EmitULEB128IntValue(asmInfo.getDwarfRegNum(Src.getReg(), isEH),
1);
}
streamer.EmitULEB128IntValue(-Src.getOffset(), 1);
continue;
}
if (Src.isReg() && Src.getReg() == MachineLocation::VirtualFP) {
assert(Dst.isReg() && "Machine move not supported yet.");
streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_register, 1);
streamer.EmitULEB128IntValue(asmInfo.getDwarfRegNum(Dst.getReg(), isEH));
continue;
}
unsigned Reg = asmInfo.getDwarfRegNum(Src.getReg(), isEH);
int Offset = Dst.getOffset() / dataAlignmentFactor;
if (Offset < 0) {
streamer.EmitIntValue(dwarf::DW_CFA_offset_extended_sf, 1);
streamer.EmitULEB128IntValue(Reg);
streamer.EmitSLEB128IntValue(Offset);
} else if (Reg < 64) {
streamer.EmitIntValue(dwarf::DW_CFA_offset + Reg, 1);
streamer.EmitULEB128IntValue(Offset, 1);
} else {
streamer.EmitIntValue(dwarf::DW_CFA_offset_extended, 1);
streamer.EmitULEB128IntValue(Reg, 1);
streamer.EmitULEB128IntValue(Offset, 1);
}
}
}
static const MCSymbol &EmitCIE(MCStreamer &streamer) {
MCContext &context = streamer.getContext();
const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
const MCSection &section = *asmInfo.getEHFrameSection();
streamer.SwitchSection(&section);
MCSymbol *sectionStart = streamer.getContext().CreateTempSymbol();
MCSymbol *sectionEnd = streamer.getContext().CreateTempSymbol();
// Length
const MCExpr *Length = MakeStartMinusEndExpr(streamer, *sectionStart,
*sectionEnd, 4);
streamer.EmitLabel(sectionStart);
streamer.EmitValue(Length, 4);
// CIE ID
streamer.EmitIntValue(0, 4);
// Version
streamer.EmitIntValue(dwarf::DW_CIE_VERSION, 1);
// Augmentation String
SmallString<8> Augmentation;
Augmentation += "zR";
streamer.EmitBytes(Augmentation.str(), 0);
streamer.EmitIntValue(0, 1);
// Code Alignment Factor
streamer.EmitULEB128IntValue(1);
// Data Alignment Factor
streamer.EmitSLEB128IntValue(getDataAlignmentFactor(streamer));
// Return Address Register
streamer.EmitULEB128IntValue(asmInfo.getDwarfRARegNum(true));
// Augmentation Data Length (optional)
MCSymbol *augmentationStart = streamer.getContext().CreateTempSymbol();
MCSymbol *augmentationEnd = streamer.getContext().CreateTempSymbol();
const MCExpr *augmentationLength = MakeStartMinusEndExpr(streamer,
*augmentationStart,
*augmentationEnd, 0);
streamer.EmitULEB128Value(augmentationLength);
// Augmentation Data (optional)
streamer.EmitLabel(augmentationStart);
streamer.EmitIntValue(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4, 1);
streamer.EmitLabel(augmentationEnd);
// Initial Instructions
const std::vector<MachineMove> Moves = asmInfo.getInitialFrameState();
EmitFrameMoves(streamer, Moves, NULL, true);
// Padding
streamer.EmitValueToAlignment(asmInfo.getPointerSize());
streamer.EmitLabel(sectionEnd);
return *sectionStart;
}
static void EmitFDE(MCStreamer &streamer,
const MCSymbol &cieStart,
const MCDwarfFrameInfo &frame) {
MCContext &context = streamer.getContext();
const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
MCSymbol *fdeStart = streamer.getContext().CreateTempSymbol();
MCSymbol *fdeEnd = streamer.getContext().CreateTempSymbol();
// Length
const MCExpr *Length = MakeStartMinusEndExpr(streamer, *fdeStart, *fdeEnd, 0);
streamer.EmitValue(Length, 4);
streamer.EmitLabel(fdeStart);
// CIE Pointer
const MCExpr *offset = MakeStartMinusEndExpr(streamer, cieStart, *fdeStart,
0);
streamer.EmitValue(offset, 4);
// PC Begin
streamer.EmitPCRelSymbolValue(frame.Begin, 4);
// PC Range
const MCExpr *Range = MakeStartMinusEndExpr(streamer, *frame.Begin,
*frame.End, 0);
streamer.EmitValue(Range, 4);
// Augmentation Data Length
streamer.EmitULEB128IntValue(0);
// Augmentation Data
// Call Frame Instructions
// Padding
streamer.EmitValueToAlignment(asmInfo.getPointerSize());
streamer.EmitLabel(fdeEnd);
}
void MCDwarfFrameEmitter::Emit(MCStreamer &streamer) {
const MCSymbol &cieStart = EmitCIE(streamer);
for (unsigned i = 0, n = streamer.getNumFrameInfos(); i < n; ++i)
EmitFDE(streamer, cieStart, streamer.getFrameInfo(i));
}

11
lib/MC/MCELFStreamer.cpp
View File

@ -30,7 +30,6 @@
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetAsmBackend.h"
#include "llvm/Target/TargetAsmInfo.h"
using namespace llvm;
@ -479,8 +478,14 @@ void MCELFStreamer::EmitInstToData(const MCInst &Inst) {
}
void MCELFStreamer::Finish() {
if (!FrameInfos.empty())
MCDwarfFrameEmitter::Emit(*this);
// FIXME: duplicated code with the MachO streamer.
// Dump out the dwarf file & directory tables and line tables.
if (getContext().hasDwarfFiles()) {
const MCSection *DwarfLineSection =
getContext().getELFSection(".debug_line", 0, 0,
SectionKind::getDataRelLocal());
MCDwarfFileTable::Emit(this, DwarfLineSection);
}
for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(),
e = LocalCommons.end();

5
lib/MC/MCLoggingStreamer.cpp
View File

@ -154,10 +154,9 @@ public:
return Child->EmitBytes(Data, AddrSpace);
}
virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
bool isPCRel, unsigned AddrSpace){
virtual void EmitValue(const MCExpr *Value, unsigned Size,unsigned AddrSpace){
LogCall("EmitValue");
return Child->EmitValueImpl(Value, Size, isPCRel, AddrSpace);
return Child->EmitValue(Value, Size, AddrSpace);
}
virtual void EmitULEB128Value(const MCExpr *Value,

10
lib/MC/MCMachOStreamer.cpp
View File

@ -24,7 +24,6 @@
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetAsmBackend.h"
#include "llvm/Target/TargetAsmInfo.h"
using namespace llvm;
@ -355,6 +354,15 @@ void MCMachOStreamer::EmitInstToData(const MCInst &Inst) {
}
void MCMachOStreamer::Finish() {
// Dump out the dwarf file & directory tables and line tables.
if (getContext().hasDwarfFiles()) {
const MCSection *DwarfLineSection = getContext().getMachOSection("__DWARF",
"__debug_line",
MCSectionMachO::S_ATTR_DEBUG,
0, SectionKind::getDataRelLocal());
MCDwarfFileTable::Emit(this, DwarfLineSection);
}
// We have to set the fragment atom associations so we can relax properly for
// Mach-O.

4
lib/MC/MCNullStreamer.cpp
View File

@ -68,8 +68,8 @@ namespace {
uint64_t Size, unsigned ByteAlignment) {}
virtual void EmitBytes(StringRef Data, unsigned AddrSpace) {}
virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
bool isPCRel, unsigned AddrSpace) {}
virtual void EmitValue(const MCExpr *Value, unsigned Size,
unsigned AddrSpace) {}
virtual void EmitULEB128Value(const MCExpr *Value,
unsigned AddrSpace = 0) {}
virtual void EmitSLEB128Value(const MCExpr *Value,

14
lib/MC/MCObjectStreamer.cpp
View File

@ -12,12 +12,10 @@
#include "llvm/Support/ErrorHandling.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCCodeEmitter.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCDwarf.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/Target/TargetAsmBackend.h"
#include "llvm/Target/TargetAsmInfo.h"
using namespace llvm;
MCObjectStreamer::MCObjectStreamer(MCContext &Context, TargetAsmBackend &TAB,
@ -76,8 +74,8 @@ const MCExpr *MCObjectStreamer::AddValueSymbols(const MCExpr *Value) {
return Value;
}
void MCObjectStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
bool isPCRel, unsigned AddrSpace) {
void MCObjectStreamer::EmitValue(const MCExpr *Value, unsigned Size,
unsigned AddrSpace) {
assert(AddrSpace == 0 && "Address space must be 0!");
MCDataFragment *DF = getOrCreateDataFragment();
@ -89,7 +87,7 @@ void MCObjectStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
}
DF->addFixup(MCFixup::Create(DF->getContents().size(),
AddValueSymbols(Value),
MCFixup::getKindForSize(Size, isPCRel)));
MCFixup::getKindForSize(Size, false)));
DF->getContents().resize(DF->getContents().size() + Size, 0);
}
@ -191,7 +189,7 @@ void MCObjectStreamer::EmitDwarfAdvanceLineAddr(int64_t LineDelta,
const MCSymbol *LastLabel,
const MCSymbol *Label) {
if (!LastLabel) {
int PointerSize = getContext().getTargetAsmInfo().getPointerSize();
int PointerSize = getAssembler().getBackend().getPointerSize();
EmitDwarfSetLineAddr(LineDelta, Label, PointerSize);
return;
}
@ -217,9 +215,5 @@ void MCObjectStreamer::EmitValueToOffset(const MCExpr *Offset,
}
void MCObjectStreamer::Finish() {
// Dump out the dwarf file & directory tables and line tables.
if (getContext().hasDwarfFiles())
MCDwarfFileTable::Emit(this);
getAssembler().Finish();
}

58
lib/MC/MCStreamer.cpp
View File

@ -85,31 +85,9 @@ void MCStreamer::EmitAbsValue(const MCExpr *Value, unsigned Size,
EmitSymbolValue(ABS, Size, AddrSpace);
}
void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size,
unsigned AddrSpace) {
EmitValueImpl(Value, Size, false, AddrSpace);
}
void MCStreamer::EmitPCRelValue(const MCExpr *Value, unsigned Size,
unsigned AddrSpace) {
EmitValueImpl(Value, Size, true, AddrSpace);
}
void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
bool isPCRel, unsigned AddrSpace) {
EmitValueImpl(MCSymbolRefExpr::Create(Sym, getContext()), Size, isPCRel,
AddrSpace);
}
void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
unsigned AddrSpace) {
EmitSymbolValue(Sym, Size, false, AddrSpace);
}
void MCStreamer::EmitPCRelSymbolValue(const MCSymbol *Sym, unsigned Size,
unsigned AddrSpace) {
EmitSymbolValue(Sym, Size, true, AddrSpace);
EmitValue(MCSymbolRefExpr::Create(Sym, getContext()), Size, AddrSpace);
}
void MCStreamer::EmitGPRel32Value(const MCExpr *Value) {
@ -138,65 +116,31 @@ void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
Discriminator);
}
MCDwarfFrameInfo *MCStreamer::getCurrentFrameInfo() {
if (FrameInfos.empty())
return NULL;
return &FrameInfos.back();
}
void MCStreamer::EnsureValidFrame() {
MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
if (!CurFrame || CurFrame->End)
report_fatal_error("No open frame");
}
bool MCStreamer::EmitCFIStartProc() {
MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
if (CurFrame && !CurFrame->End) {
report_fatal_error("Starting a frame before finishing the previous one!");
return true;
}
MCDwarfFrameInfo Frame = {0, 0, 0, 0};
Frame.Begin = getContext().CreateTempSymbol();
EmitLabel(Frame.Begin);
FrameInfos.push_back(Frame);
return false;
}
bool MCStreamer::EmitCFIEndProc() {
EnsureValidFrame();
MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
CurFrame->End = getContext().CreateTempSymbol();
EmitLabel(CurFrame->End);
return false;
}
bool MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
EnsureValidFrame();
return false;
}
bool MCStreamer::EmitCFIDefCfaRegister(int64_t Register) {
EnsureValidFrame();
return false;
}
bool MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
EnsureValidFrame();
return false;
}
bool MCStreamer::EmitCFIPersonality(const MCSymbol *Sym) {
EnsureValidFrame();
MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
CurFrame->Personality = Sym;
return false;
}
bool MCStreamer::EmitCFILsda(const MCSymbol *Sym) {
EnsureValidFrame();
MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo();
CurFrame->Lsda = Sym;
return false;
}

2
lib/Target/CBackend/CBackend.cpp
View File

@ -1755,7 +1755,7 @@ bool CWriter::doInitialization(Module &M) {
TAsm = Match->createAsmInfo(Triple);
#endif
TAsm = new CBEMCAsmInfo();
TCtx = new MCContext(*TAsm, NULL);
TCtx = new MCContext(*TAsm);
Mang = new Mangler(*TCtx, *TD);
// Keep track of which functions are static ctors/dtors so they can have

25
lib/Target/PTX/PTXMCAsmStreamer.cpp
View File

@ -23,7 +23,6 @@
#include "llvm/Support/Format.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetAsmInfo.h"
using namespace llvm;
@ -37,19 +36,21 @@ class PTXMCAsmStreamer : public MCStreamer {
SmallString<128> CommentToEmit;
raw_svector_ostream CommentStream;
unsigned IsLittleEndian : 1;
unsigned IsVerboseAsm : 1;
unsigned ShowInst : 1;
public:
PTXMCAsmStreamer(MCContext &Context,
formatted_raw_ostream &os,
bool isVerboseAsm, bool useLoc,
bool isLittleEndian,
bool isVerboseAsm,
MCInstPrinter *printer,
MCCodeEmitter *emitter,
bool showInst)
: MCStreamer(Context), OS(os), MAI(Context.getAsmInfo()),
InstPrinter(printer), Emitter(emitter), CommentStream(CommentToEmit),
IsVerboseAsm(isVerboseAsm),
IsLittleEndian(isLittleEndian), IsVerboseAsm(isVerboseAsm),
ShowInst(showInst) {
if (InstPrinter && IsVerboseAsm)
InstPrinter->setCommentStream(CommentStream);
@ -57,6 +58,8 @@ public:
~PTXMCAsmStreamer() {}
bool isLittleEndian() const { return IsLittleEndian; }
inline void EmitEOL() {
// If we don't have any comments, just emit a \n.
if (!IsVerboseAsm) {
@ -144,8 +147,7 @@ public:
virtual void EmitBytes(StringRef Data, unsigned AddrSpace);
virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
bool isPCRel, unsigned AddrSpace);
virtual void EmitValue(const MCExpr *Value, unsigned Size,unsigned AddrSpace);
virtual void EmitULEB128Value(const MCExpr *Value, unsigned AddrSpace = 0);
virtual void EmitSLEB128Value(const MCExpr *Value, unsigned AddrSpace = 0);
virtual void EmitGPRel32Value(const MCExpr *Value);
@ -357,10 +359,9 @@ void PTXMCAsmStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) {
EmitEOL();
}
void PTXMCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
bool isPCRel, unsigned AddrSpace) {
void PTXMCAsmStreamer::EmitValue(const MCExpr *Value, unsigned Size,
unsigned AddrSpace) {
assert(CurSection && "Cannot emit contents before setting section!");
assert(!isPCRel && "Cannot emit pc relative relocations!");
const char *Directive = 0;
switch (Size) {
default: break;
@ -374,7 +375,7 @@ void PTXMCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
int64_t IntValue;
if (!Value->EvaluateAsAbsolute(IntValue))
report_fatal_error("Don't know how to emit this value.");
if (getContext().getTargetAsmInfo().isLittleEndian()) {
if (isLittleEndian()) {
EmitIntValue((uint32_t)(IntValue >> 0 ), 4, AddrSpace);
EmitIntValue((uint32_t)(IntValue >> 32), 4, AddrSpace);
} else {
@ -538,10 +539,10 @@ void PTXMCAsmStreamer::Finish() {}
namespace llvm {
MCStreamer *createPTXAsmStreamer(MCContext &Context,
formatted_raw_ostream &OS,
bool isVerboseAsm, bool useLoc,
MCInstPrinter *IP,
bool isLittleEndian,
bool isVerboseAsm, MCInstPrinter *IP,
MCCodeEmitter *CE, bool ShowInst) {
return new PTXMCAsmStreamer(Context, OS, isVerboseAsm, useLoc,
return new PTXMCAsmStreamer(Context, OS, isLittleEndian, isVerboseAsm,
IP, CE, ShowInst);
}
}

2
lib/Target/PTX/PTXTargetMachine.cpp
View File

@ -21,7 +21,7 @@ using namespace llvm;
namespace llvm {
MCStreamer *createPTXAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
bool isVerboseAsm, bool useLoc,
bool isLittleEndian, bool isVerboseAsm,
MCInstPrinter *InstPrint,
MCCodeEmitter *CE,
bool ShowInst);

27
lib/Target/TargetAsmInfo.cpp
View File

@ -1,27 +0,0 @@
//===-- llvm/Target/TargetAsmInfo.cpp - Target Assembly Info --------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLowering.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetRegisterInfo.h"
using namespace llvm;
TargetAsmInfo::TargetAsmInfo(const TargetMachine &TM) {
TLOF = &TM.getTargetLowering()->getObjFileLowering();
const TargetData &TD = *TM.getTargetData();
IsLittleEndian = TD.isLittleEndian();
PointerSize = TD.getPointerSize();
const TargetFrameInfo &TFI = *TM.getFrameInfo();
StackDir = TFI.getStackGrowthDirection();
TRI = TM.getRegisterInfo();
TFI.getInitialFrameState(InitialFrameState);
}

23
lib/Target/X86/X86AsmBackend.cpp
View File

@ -279,6 +279,10 @@ public:
ELFX86_32AsmBackend(const Target &T, Triple::OSType OSType)
: ELFX86AsmBackend(T, OSType) {}
unsigned getPointerSize() const {
return 4;
}
MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
return createELFObjectWriter(OS, /*Is64Bit=*/false,
OSType, ELF::EM_386,
@ -292,6 +296,10 @@ public:
ELFX86_64AsmBackend(const Target &T, Triple::OSType OSType)
: ELFX86AsmBackend(T, OSType) {}
unsigned getPointerSize() const {
return 8;
}
MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
return createELFObjectWriter(OS, /*Is64Bit=*/true,
OSType, ELF::EM_X86_64,
@ -315,6 +323,13 @@ public:
return Format;
}
unsigned getPointerSize() const {
if (Is64Bit)
return 8;
else
return 4;
}
MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
return createWinCOFFObjectWriter(OS, Is64Bit);
}
@ -339,6 +354,10 @@ public:
DarwinX86_32AsmBackend(const Target &T)
: DarwinX86AsmBackend(T) {}
unsigned getPointerSize() const {
return 4;
}
MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
return createMachObjectWriter(OS, /*Is64Bit=*/false,
object::mach::CTM_i386,
@ -354,6 +373,10 @@ public:
HasReliableSymbolDifference = true;
}
unsigned getPointerSize() const {
return 8;
}
MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
return createMachObjectWriter(OS, /*Is64Bit=*/true,
object::mach::CTM_x86_64,

41
test/MC/ELF/cfi.s
View File

@ -1,41 +0,0 @@
// RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o - | elf-dump --dump-section-data | FileCheck %s
f:
.cfi_startproc
nop
.cfi_endproc
// CHECK: # Section 0x00000004
// CHECK-NEXT: (('sh_name', 0x00000012) # '.eh_frame'
// CHECK-NEXT: ('sh_type', 0x00000001)
// CHECK-NEXT: ('sh_flags', 0x00000002)
// CHECK-NEXT: ('sh_addr', 0x00000000)
// CHECK-NEXT: ('sh_offset', 0x00000048)
// CHECK-NEXT: ('sh_size', 0x00000030)
// CHECK-NEXT: ('sh_link', 0x00000000)
// CHECK-NEXT: ('sh_info', 0x00000000)
// CHECK-NEXT: ('sh_addralign', 0x00000008)
// CHECK-NEXT: ('sh_entsize', 0x00000000)
// CHECK-NEXT: ('_section_data', '14000000 00000000 017a5200 01781001 1b0c0708 90010000 14000000 1c000000 00000000 01000000 00000000 00000000')
// CHECK-NEXT: ),
// CHECK: # Section 0x00000008
// CHECK-NEXT: (('sh_name', 0x00000036) # '.rela.eh_frame'
// CHECK-NEXT: ('sh_type', 0x00000004)
// CHECK-NEXT: ('sh_flags', 0x00000000)
// CHECK-NEXT: ('sh_addr', 0x00000000)
// CHECK-NEXT: ('sh_offset', 0x00000158)
// CHECK-NEXT: ('sh_size', 0x00000018)
// CHECK-NEXT: ('sh_link', 0x00000006)
// CHECK-NEXT: ('sh_info', 0x00000004)
// CHECK-NEXT: ('sh_addralign', 0x00000008)
// CHECK-NEXT: ('sh_entsize', 0x00000018)
// CHECK-NEXT: ('_relocations', [
// CHECK-NEXT: # Relocation 0x00000000
// CHECK-NEXT: (('r_offset', 0x00000020)
// CHECK-NEXT: ('r_sym', 0x00000002)
// CHECK-NEXT: ('r_type', 0x00000002)
// CHECK-NEXT: ('r_addend', 0x00000000)
// CHECK-NEXT: ),
// CHECK-NEXT: ])
// CHECK-NEXT: ),

2
test/MC/ELF/empty-dwarf-lines.s
View File

@ -9,7 +9,7 @@ c:
// CHECK: # Section 0x00000004
// CHECK-NEXT: (('sh_name', 0x00000012) # '.debug_line'
// CHECK-NEXT: ('sh_type', 0x00000001)
// CHECK-NEXT: ('sh_type', 0x00000000)
// CHECK-NEXT: ('sh_flags', 0x00000000)
// CHECK-NEXT: ('sh_addr', 0x00000000)
// CHECK-NEXT: ('sh_offset', 0x00000044)

17
tools/llvm-mc/llvm-mc.cpp
View File

@ -24,9 +24,6 @@
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetRegistry.h"
#include "llvm/Target/SubtargetFeature.h" // FIXME.
#include "llvm/Target/TargetAsmInfo.h" // FIXME.
#include "llvm/Target/TargetLowering.h" // FIXME.
#include "llvm/Target/TargetLoweringObjectFile.h" // FIXME.
#include "llvm/Target/TargetMachine.h" // FIXME.
#include "llvm/Target/TargetSelect.h"
#include "llvm/ADT/OwningPtr.h"
@ -301,6 +298,8 @@ static int AssembleInput(const char *ProgName) {
llvm::OwningPtr<MCAsmInfo> MAI(TheTarget->createAsmInfo(TripleName));
assert(MAI && "Unable to create target asm info!");
MCContext Ctx(*MAI);
// Package up features to be passed to target/subtarget
std::string FeaturesStr;
if (MCPU.size()) {
@ -322,9 +321,6 @@ static int AssembleInput(const char *ProgName) {
return 1;
}
const TargetAsmInfo tai(*TM);
MCContext Ctx(*MAI, &tai);
OwningPtr<tool_output_file> Out(GetOutputStream());
if (!Out)
return 1;
@ -332,18 +328,15 @@ static int AssembleInput(const char *ProgName) {
formatted_raw_ostream FOS(Out->os());
OwningPtr<MCStreamer> Str;
const TargetLoweringObjectFile &TLOF =
TM->getTargetLowering()->getObjFileLowering();
const_cast<TargetLoweringObjectFile&>(TLOF).Initialize(Ctx, *TM);
if (FileType == OFT_AssemblyFile) {
MCInstPrinter *IP =
TheTarget->createMCInstPrinter(OutputAsmVariant, *MAI);
MCCodeEmitter *CE = 0;
if (ShowEncoding)
CE = TheTarget->createCodeEmitter(*TM, Ctx);
Str.reset(TheTarget->createAsmStreamer(Ctx, FOS, /*asmverbose*/true,
/*useLoc*/ true, IP, CE, ShowInst));
Str.reset(TheTarget->createAsmStreamer(Ctx, FOS,
TM->getTargetData()->isLittleEndian(),
/*asmverbose*/true, IP, CE, ShowInst));
} else if (FileType == OFT_Null) {
Str.reset(createNullStreamer(Ctx));
} else {

2
tools/lto/LTOCodeGenerator.cpp
View File

@ -347,7 +347,7 @@ void LTOCodeGenerator::applyScopeRestrictions() {
// mark which symbols can not be internalized
if (!_mustPreserveSymbols.empty()) {
MCContext Context(*_target->getMCAsmInfo(), NULL);
MCContext Context(*_target->getMCAsmInfo());
Mangler mangler(Context, *_target->getTargetData());
std::vector<const char*> mustPreserveList;
for (Module::iterator f = mergedModule->begin(),

2
tools/lto/LTOModule.cpp
View File

@ -428,7 +428,7 @@ void LTOModule::lazyParseSymbols() {
_symbolsParsed = true;
// Use mangler to add GlobalPrefix to names to match linker names.
MCContext Context(*_target->getMCAsmInfo(), NULL);
MCContext Context(*_target->getMCAsmInfo());
Mangler mangler(Context, *_target->getTargetData());
// add functions