summaryrefslogtreecommitdiffstats
path: root/include/llvm/CodeGen
diff options
context:
space:
mode:
Diffstat (limited to 'include/llvm/CodeGen')
-rw-r--r--include/llvm/CodeGen/AsmPrinter.h20
-rw-r--r--include/llvm/CodeGen/IntrinsicLowering.h6
-rw-r--r--include/llvm/CodeGen/MachineInstrBuilder.h48
-rw-r--r--include/llvm/CodeGen/MachineOperand.h45
-rw-r--r--include/llvm/CodeGen/SelectionDAG.h37
-rw-r--r--include/llvm/CodeGen/SelectionDAGNodes.h47
-rw-r--r--include/llvm/CodeGen/ValueTypes.h7
7 files changed, 118 insertions, 92 deletions
diff --git a/include/llvm/CodeGen/AsmPrinter.h b/include/llvm/CodeGen/AsmPrinter.h
index a004632..f3ca306 100644
--- a/include/llvm/CodeGen/AsmPrinter.h
+++ b/include/llvm/CodeGen/AsmPrinter.h
@@ -33,6 +33,7 @@ namespace llvm {
class GlobalVariable;
class MachineConstantPoolEntry;
class MachineConstantPoolValue;
+ class MachineModuleInfo;
class DwarfWriter;
class Mangler;
class Section;
@@ -58,14 +59,12 @@ namespace llvm {
gcp_map_type GCMetadataPrinters;
protected:
- /// DW -This is needed because printDeclare() has to insert
- /// DbgVariable entries into the dwarf table. This is a short term hack
- /// that ought be fixed soon.
+ /// MMI - If available, this is a pointer to the current MachineModuleInfo.
+ MachineModuleInfo *MMI;
+
+ /// DW - If available, this is a pointer to the current dwarf writer.
DwarfWriter *DW;
- // Necessary for external weak linkage support
- std::set<const GlobalValue*> ExtWeakSymbols;
-
/// OptLevel - Generating code at a specific optimization level.
CodeGenOpt::Level OptLevel;
public:
@@ -110,6 +109,15 @@ namespace llvm {
///
bool VerboseAsm;
+ /// Private state for PrintSpecial()
+ // Assign a unique ID to this machine instruction.
+ mutable const MachineInstr *LastMI;
+ mutable const Function *LastFn;
+ mutable unsigned Counter;
+
+ // Private state for processDebugLock()
+ mutable DebugLocTuple PrevDLT;
+
protected:
explicit AsmPrinter(raw_ostream &o, TargetMachine &TM,
const TargetAsmInfo *T, CodeGenOpt::Level OL, bool V);
diff --git a/include/llvm/CodeGen/IntrinsicLowering.h b/include/llvm/CodeGen/IntrinsicLowering.h
index 6628329..eefbc45 100644
--- a/include/llvm/CodeGen/IntrinsicLowering.h
+++ b/include/llvm/CodeGen/IntrinsicLowering.h
@@ -25,8 +25,12 @@ namespace llvm {
class IntrinsicLowering {
const TargetData& TD;
+
+
+ bool Warned;
public:
- explicit IntrinsicLowering(const TargetData &td) : TD(td) {}
+ explicit IntrinsicLowering(const TargetData &td) :
+ TD(td), Warned(false) {}
/// AddPrototypes - This method, if called, causes all of the prototypes
/// that might be needed by an intrinsic lowering implementation to be
diff --git a/include/llvm/CodeGen/MachineInstrBuilder.h b/include/llvm/CodeGen/MachineInstrBuilder.h
index d3a0995..3f30de5 100644
--- a/include/llvm/CodeGen/MachineInstrBuilder.h
+++ b/include/llvm/CodeGen/MachineInstrBuilder.h
@@ -74,8 +74,9 @@ public:
return *this;
}
- const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB) const {
- MI->addOperand(MachineOperand::CreateMBB(MBB));
+ const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB,
+ unsigned char TargetFlags = 0) const {
+ MI->addOperand(MachineOperand::CreateMBB(MBB, TargetFlags));
return *this;
}
@@ -85,25 +86,29 @@ public:
}
const MachineInstrBuilder &addConstantPoolIndex(unsigned Idx,
- int Offset = 0) const {
- MI->addOperand(MachineOperand::CreateCPI(Idx, Offset));
+ int Offset = 0,
+ unsigned char TargetFlags = 0) const {
+ MI->addOperand(MachineOperand::CreateCPI(Idx, Offset, TargetFlags));
return *this;
}
- const MachineInstrBuilder &addJumpTableIndex(unsigned Idx) const {
- MI->addOperand(MachineOperand::CreateJTI(Idx));
+ const MachineInstrBuilder &addJumpTableIndex(unsigned Idx,
+ unsigned char TargetFlags = 0) const {
+ MI->addOperand(MachineOperand::CreateJTI(Idx, TargetFlags));
return *this;
}
const MachineInstrBuilder &addGlobalAddress(GlobalValue *GV,
- int64_t Offset = 0) const {
- MI->addOperand(MachineOperand::CreateGA(GV, Offset));
+ int64_t Offset = 0,
+ unsigned char TargetFlags = 0) const {
+ MI->addOperand(MachineOperand::CreateGA(GV, Offset, TargetFlags));
return *this;
}
const MachineInstrBuilder &addExternalSymbol(const char *FnName,
- int64_t Offset = 0) const {
- MI->addOperand(MachineOperand::CreateES(FnName, Offset));
+ int64_t Offset = 0,
+ unsigned char TargetFlags = 0) const {
+ MI->addOperand(MachineOperand::CreateES(FnName, Offset, TargetFlags));
return *this;
}
@@ -113,28 +118,7 @@ public:
}
const MachineInstrBuilder &addOperand(const MachineOperand &MO) const {
- if (MO.isReg())
- return addReg(MO.getReg(),
- (MO.isDef() ? RegState::Define : 0) |
- (MO.isImplicit() ? RegState::Implicit : 0) |
- (MO.isKill() ? RegState::Kill : 0) |
- (MO.isDead() ? RegState::Dead : 0) |
- (MO.isEarlyClobber() ? RegState::EarlyClobber : 0),
- MO.getSubReg());
- if (MO.isImm())
- return addImm(MO.getImm());
- if (MO.isFI())
- return addFrameIndex(MO.getIndex());
- if (MO.isGlobal())
- return addGlobalAddress(MO.getGlobal(), MO.getOffset());
- if (MO.isCPI())
- return addConstantPoolIndex(MO.getIndex(), MO.getOffset());
- if (MO.isSymbol())
- return addExternalSymbol(MO.getSymbolName());
- if (MO.isJTI())
- return addJumpTableIndex(MO.getIndex());
-
- assert(0 && "Unknown operand for MachineInstrBuilder::AddOperand!");
+ MI->addOperand(MO);
return *this;
}
};
diff --git a/include/llvm/CodeGen/MachineOperand.h b/include/llvm/CodeGen/MachineOperand.h
index ba538d7..5a7f76b 100644
--- a/include/llvm/CodeGen/MachineOperand.h
+++ b/include/llvm/CodeGen/MachineOperand.h
@@ -47,7 +47,14 @@ public:
private:
/// OpKind - Specify what kind of operand this is. This discriminates the
/// union.
- MachineOperandType OpKind : 8;
+ unsigned char OpKind; // MachineOperandType
+
+ /// SubReg - Subregister number, only valid for MO_Register. A value of 0
+ /// indicates the MO_Register has no subReg.
+ unsigned char SubReg;
+
+ /// TargetFlags - This is a set of target-specific operand flags.
+ unsigned char TargetFlags;
/// IsDef/IsImp/IsKill/IsDead flags - These are only valid for MO_Register
/// operands.
@@ -73,10 +80,6 @@ private:
/// model the GCC inline asm '&' constraint modifier.
bool IsEarlyClobber : 1;
- /// SubReg - Subregister number, only valid for MO_Register. A value of 0
- /// indicates the MO_Register has no subReg.
- unsigned char SubReg;
-
/// ParentMI - This is the instruction that this operand is embedded into.
/// This is valid for all operand types, when the operand is in an instr.
MachineInstr *ParentMI;
@@ -105,7 +108,9 @@ private:
} OffsetedInfo;
} Contents;
- explicit MachineOperand(MachineOperandType K) : OpKind(K), ParentMI(0) {}
+ explicit MachineOperand(MachineOperandType K) : OpKind(K), ParentMI(0) {
+ TargetFlags = 0;
+ }
public:
MachineOperand(const MachineOperand &M) {
*this = M;
@@ -115,7 +120,12 @@ public:
/// getType - Returns the MachineOperandType for this operand.
///
- MachineOperandType getType() const { return OpKind; }
+ MachineOperandType getType() const { return (MachineOperandType)OpKind; }
+
+ unsigned char getTargetFlags() const { return TargetFlags; }
+ void setTargetFlags(unsigned char F) { TargetFlags = F; }
+ void addTargetFlag(unsigned char F) { TargetFlags |= F; }
+
/// getParent - Return the instruction that this operand belongs to.
///
@@ -361,9 +371,11 @@ public:
Op.SubReg = SubReg;
return Op;
}
- static MachineOperand CreateMBB(MachineBasicBlock *MBB) {
+ static MachineOperand CreateMBB(MachineBasicBlock *MBB,
+ unsigned char TargetFlags = 0) {
MachineOperand Op(MachineOperand::MO_MachineBasicBlock);
Op.setMBB(MBB);
+ Op.setTargetFlags(TargetFlags);
return Op;
}
static MachineOperand CreateFI(unsigned Idx) {
@@ -371,27 +383,35 @@ public:
Op.setIndex(Idx);
return Op;
}
- static MachineOperand CreateCPI(unsigned Idx, int Offset) {
+ static MachineOperand CreateCPI(unsigned Idx, int Offset,
+ unsigned char TargetFlags = 0) {
MachineOperand Op(MachineOperand::MO_ConstantPoolIndex);
Op.setIndex(Idx);
Op.setOffset(Offset);
+ Op.setTargetFlags(TargetFlags);
return Op;
}
- static MachineOperand CreateJTI(unsigned Idx) {
+ static MachineOperand CreateJTI(unsigned Idx,
+ unsigned char TargetFlags = 0) {
MachineOperand Op(MachineOperand::MO_JumpTableIndex);
Op.setIndex(Idx);
+ Op.setTargetFlags(TargetFlags);
return Op;
}
- static MachineOperand CreateGA(GlobalValue *GV, int64_t Offset) {
+ static MachineOperand CreateGA(GlobalValue *GV, int64_t Offset,
+ unsigned char TargetFlags = 0) {
MachineOperand Op(MachineOperand::MO_GlobalAddress);
Op.Contents.OffsetedInfo.Val.GV = GV;
Op.setOffset(Offset);
+ Op.setTargetFlags(TargetFlags);
return Op;
}
- static MachineOperand CreateES(const char *SymName, int64_t Offset = 0) {
+ static MachineOperand CreateES(const char *SymName, int64_t Offset = 0,
+ unsigned char TargetFlags = 0) {
MachineOperand Op(MachineOperand::MO_ExternalSymbol);
Op.Contents.OffsetedInfo.Val.SymbolName = SymName;
Op.setOffset(Offset);
+ Op.setTargetFlags(TargetFlags);
return Op;
}
const MachineOperand &operator=(const MachineOperand &MO) {
@@ -404,6 +424,7 @@ public:
SubReg = MO.SubReg;
ParentMI = MO.ParentMI;
Contents = MO.Contents;
+ TargetFlags = MO.TargetFlags;
return *this;
}
diff --git a/include/llvm/CodeGen/SelectionDAG.h b/include/llvm/CodeGen/SelectionDAG.h
index ec2d1d7..bac3eec 100644
--- a/include/llvm/CodeGen/SelectionDAG.h
+++ b/include/llvm/CodeGen/SelectionDAG.h
@@ -278,31 +278,37 @@ public:
return getConstantFP(Val, VT, true);
}
SDValue getGlobalAddress(const GlobalValue *GV, MVT VT,
- int64_t offset = 0, bool isTargetGA = false);
+ int64_t offset = 0, bool isTargetGA = false,
+ unsigned char TargetFlags = 0);
SDValue getTargetGlobalAddress(const GlobalValue *GV, MVT VT,
- int64_t offset = 0) {
- return getGlobalAddress(GV, VT, offset, true);
+ int64_t offset = 0,
+ unsigned char TargetFlags = 0) {
+ return getGlobalAddress(GV, VT, offset, true, TargetFlags);
}
SDValue getFrameIndex(int FI, MVT VT, bool isTarget = false);
SDValue getTargetFrameIndex(int FI, MVT VT) {
return getFrameIndex(FI, VT, true);
}
- SDValue getJumpTable(int JTI, MVT VT, bool isTarget = false);
- SDValue getTargetJumpTable(int JTI, MVT VT) {
- return getJumpTable(JTI, VT, true);
+ SDValue getJumpTable(int JTI, MVT VT, bool isTarget = false,
+ unsigned char TargetFlags = 0);
+ SDValue getTargetJumpTable(int JTI, MVT VT, unsigned char TargetFlags = 0) {
+ return getJumpTable(JTI, VT, true, TargetFlags);
}
SDValue getConstantPool(Constant *C, MVT VT,
- unsigned Align = 0, int Offs = 0, bool isT=false);
+ unsigned Align = 0, int Offs = 0, bool isT=false,
+ unsigned char TargetFlags = 0);
SDValue getTargetConstantPool(Constant *C, MVT VT,
- unsigned Align = 0, int Offset = 0) {
- return getConstantPool(C, VT, Align, Offset, true);
+ unsigned Align = 0, int Offset = 0,
+ unsigned char TargetFlags = 0) {
+ return getConstantPool(C, VT, Align, Offset, true, TargetFlags);
}
SDValue getConstantPool(MachineConstantPoolValue *C, MVT VT,
- unsigned Align = 0, int Offs = 0, bool isT=false);
+ unsigned Align = 0, int Offs = 0, bool isT=false,
+ unsigned char TargetFlags = 0);
SDValue getTargetConstantPool(MachineConstantPoolValue *C,
MVT VT, unsigned Align = 0,
- int Offset = 0) {
- return getConstantPool(C, VT, Align, Offset, true);
+ int Offset = 0, unsigned char TargetFlags=0) {
+ return getConstantPool(C, VT, Align, Offset, true, TargetFlags);
}
// When generating a branch to a BB, we don't in general know enough
// to provide debug info for the BB at that time, so keep this one around.
@@ -310,8 +316,8 @@ public:
SDValue getBasicBlock(MachineBasicBlock *MBB, DebugLoc dl);
SDValue getExternalSymbol(const char *Sym, MVT VT);
SDValue getExternalSymbol(const char *Sym, DebugLoc dl, MVT VT);
- SDValue getTargetExternalSymbol(const char *Sym, MVT VT);
- SDValue getTargetExternalSymbol(const char *Sym, DebugLoc dl, MVT VT);
+ SDValue getTargetExternalSymbol(const char *Sym, MVT VT,
+ unsigned char TargetFlags = 0);
SDValue getArgFlags(ISD::ArgFlagsTy Flags);
SDValue getValueType(MVT);
SDValue getRegister(unsigned Reg, MVT VT);
@@ -862,7 +868,8 @@ private:
std::vector<SDNode*> ValueTypeNodes;
std::map<MVT, SDNode*, MVT::compareRawBits> ExtendedValueTypeNodes;
StringMap<SDNode*> ExternalSymbols;
- StringMap<SDNode*> TargetExternalSymbols;
+
+ std::map<std::pair<std::string, unsigned char>,SDNode*> TargetExternalSymbols;
};
template <> struct GraphTraits<SelectionDAG*> : public GraphTraits<SDNode*> {
diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h
index 1b6fecd..adf0478 100644
--- a/include/llvm/CodeGen/SelectionDAGNodes.h
+++ b/include/llvm/CodeGen/SelectionDAGNodes.h
@@ -1819,13 +1819,15 @@ public:
class GlobalAddressSDNode : public SDNode {
GlobalValue *TheGlobal;
int64_t Offset;
+ unsigned char TargetFlags;
friend class SelectionDAG;
- GlobalAddressSDNode(bool isTarget, const GlobalValue *GA, MVT VT,
- int64_t o = 0);
+ GlobalAddressSDNode(unsigned Opc, const GlobalValue *GA, MVT VT,
+ int64_t o, unsigned char TargetFlags);
public:
GlobalValue *getGlobal() const { return TheGlobal; }
int64_t getOffset() const { return Offset; }
+ unsigned char getTargetFlags() const { return TargetFlags; }
// Return the address space this GlobalAddress belongs to.
unsigned getAddressSpace() const;
@@ -1858,14 +1860,16 @@ public:
class JumpTableSDNode : public SDNode {
int JTI;
+ unsigned char TargetFlags;
friend class SelectionDAG;
- JumpTableSDNode(int jti, MVT VT, bool isTarg)
+ JumpTableSDNode(int jti, MVT VT, bool isTarg, unsigned char TF)
: SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable,
- DebugLoc::getUnknownLoc(), getSDVTList(VT)), JTI(jti) {
+ DebugLoc::getUnknownLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) {
}
public:
int getIndex() const { return JTI; }
+ unsigned char getTargetFlags() const { return TargetFlags; }
static bool classof(const JumpTableSDNode *) { return true; }
static bool classof(const SDNode *N) {
@@ -1881,40 +1885,27 @@ class ConstantPoolSDNode : public SDNode {
} Val;
int Offset; // It's a MachineConstantPoolValue if top bit is set.
unsigned Alignment; // Minimum alignment requirement of CP (not log2 value).
+ unsigned char TargetFlags;
friend class SelectionDAG;
- ConstantPoolSDNode(bool isTarget, Constant *c, MVT VT, int o=0)
+ ConstantPoolSDNode(bool isTarget, Constant *c, MVT VT, int o, unsigned Align,
+ unsigned char TF)
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool,
DebugLoc::getUnknownLoc(),
- getSDVTList(VT)), Offset(o), Alignment(0) {
+ getSDVTList(VT)), Offset(o), Alignment(Align), TargetFlags(TF) {
assert((int)Offset >= 0 && "Offset is too large");
Val.ConstVal = c;
}
- ConstantPoolSDNode(bool isTarget, Constant *c, MVT VT, int o, unsigned Align)
- : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool,
- DebugLoc::getUnknownLoc(),
- getSDVTList(VT)), Offset(o), Alignment(Align) {
- assert((int)Offset >= 0 && "Offset is too large");
- Val.ConstVal = c;
- }
- ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
- MVT VT, int o=0)
- : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool,
- DebugLoc::getUnknownLoc(),
- getSDVTList(VT)), Offset(o), Alignment(0) {
- assert((int)Offset >= 0 && "Offset is too large");
- Val.MachineCPVal = v;
- Offset |= 1 << (sizeof(unsigned)*CHAR_BIT-1);
- }
ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
- MVT VT, int o, unsigned Align)
+ MVT VT, int o, unsigned Align, unsigned char TF)
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool,
DebugLoc::getUnknownLoc(),
- getSDVTList(VT)), Offset(o), Alignment(Align) {
+ getSDVTList(VT)), Offset(o), Alignment(Align), TargetFlags(TF) {
assert((int)Offset >= 0 && "Offset is too large");
Val.MachineCPVal = v;
Offset |= 1 << (sizeof(unsigned)*CHAR_BIT-1);
}
public:
+
bool isMachineConstantPoolEntry() const {
return (int)Offset < 0;
@@ -1937,6 +1928,7 @@ public:
// Return the alignment of this constant pool object, which is either 0 (for
// default alignment) or the desired value.
unsigned getAlignment() const { return Alignment; }
+ unsigned char getTargetFlags() const { return TargetFlags; }
const Type *getType() const;
@@ -2101,15 +2093,18 @@ public:
class ExternalSymbolSDNode : public SDNode {
const char *Symbol;
+ unsigned char TargetFlags;
+
friend class SelectionDAG;
- ExternalSymbolSDNode(bool isTarget, const char *Sym, MVT VT)
+ ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned char TF, MVT VT)
: SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol,
DebugLoc::getUnknownLoc(),
- getSDVTList(VT)), Symbol(Sym) {
+ getSDVTList(VT)), Symbol(Sym), TargetFlags(TF) {
}
public:
const char *getSymbol() const { return Symbol; }
+ unsigned char getTargetFlags() const { return TargetFlags; }
static bool classof(const ExternalSymbolSDNode *) { return true; }
static bool classof(const SDNode *N) {
diff --git a/include/llvm/CodeGen/ValueTypes.h b/include/llvm/CodeGen/ValueTypes.h
index 95c3a11..bf8b19c 100644
--- a/include/llvm/CodeGen/ValueTypes.h
+++ b/include/llvm/CodeGen/ValueTypes.h
@@ -1,3 +1,4 @@
+
//===- CodeGen/ValueTypes.h - Low-Level Target independ. types --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
@@ -72,6 +73,12 @@ namespace llvm {
LAST_VALUETYPE = 30, // This always remains at the end of the list.
+ // This is the current maximum for LAST_VALUETYPE.
+ // Affects ValueTypeActions in TargetLowering.h.
+ // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
+ // This value must be a multiple of 32.
+ MAX_ALLOWED_VALUETYPE = 64,
+
// iPTRAny - An int value the size of the pointer of the current
// target to any address space. This must only be used internal to
// tblgen. Other than for overloading, we treat iPTRAny the same as iPTR.
OpenPOWER on IntegriCloud