#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/Support/DebugLoc.h"
#include "llvm/Target/TargetMachine.h"
+#include "llvm/ADT/DenseMap.h"
namespace llvm {
class BlockAddress;
#ifndef LLVM_CODEGEN_MACHINEINSTR_H
#define LLVM_CODEGEN_MACHINEINSTR_H
-#include "llvm/ADT/ilist.h"
-#include "llvm/ADT/ilist_node.h"
-#include "llvm/ADT/STLExtras.h"
#include "llvm/CodeGen/MachineOperand.h"
#include "llvm/Target/TargetInstrDesc.h"
#include "llvm/Target/TargetOpcodes.h"
+#include "llvm/ADT/ilist.h"
+#include "llvm/ADT/ilist_node.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/Support/DebugLoc.h"
#include <vector>
Instruction(const Instruction &); // Do not implement
BasicBlock *Parent;
- NewDebugLoc DbgLoc; // 'dbg' Metadata cache.
+ DebugLoc DbgLoc; // 'dbg' Metadata cache.
enum {
/// HasMetadataBit - This is a bit stored in the SubClassData field which
}
/// setDebugLoc - Set the debug location information for this instruction.
- void setDebugLoc(const NewDebugLoc &Loc) { DbgLoc = Loc; }
+ void setDebugLoc(const DebugLoc &Loc) { DbgLoc = Loc; }
/// getDebugLoc - Return the debug location for this node as a DebugLoc.
- const NewDebugLoc &getDebugLoc() const { return DbgLoc; }
+ const DebugLoc &getDebugLoc() const { return DbgLoc; }
private:
/// hasMetadataHashEntry - Return true if we have an entry in the on-the-side
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_DEBUGLOC_H
-#define LLVM_DEBUGLOC_H
-
-#include "llvm/ADT/DenseMap.h"
-#include <vector>
+#ifndef LLVM_SUPPORT_DEBUGLOC_H
+#define LLVM_SUPPORT_DEBUGLOC_H
namespace llvm {
class MDNode;
/// DebugLoc - Debug location id. This is carried by Instruction, SDNode,
/// and MachineInstr to compactly encode file/line/scope information for an
/// operation.
- class NewDebugLoc {
+ class DebugLoc {
/// LineCol - This 32-bit value encodes the line and column number for the
/// location, encoded as 24-bits for line and 8 bits for col. A value of 0
/// for either means unknown.
/// decoded by LLVMContext. 0 is unknown.
int ScopeIdx;
public:
- NewDebugLoc() : LineCol(0), ScopeIdx(0) {} // Defaults to unknown.
+ DebugLoc() : LineCol(0), ScopeIdx(0) {} // Defaults to unknown.
/// get - Get a new DebugLoc that corresponds to the specified line/col
/// scope/inline location.
- static NewDebugLoc get(unsigned Line, unsigned Col,
- MDNode *Scope, MDNode *InlinedAt = 0);
+ static DebugLoc get(unsigned Line, unsigned Col,
+ MDNode *Scope, MDNode *InlinedAt = 0);
- /// getFromDILocation - Translate the DILocation quad into a NewDebugLoc.
- static NewDebugLoc getFromDILocation(MDNode *N);
+ /// getFromDILocation - Translate the DILocation quad into a DebugLoc.
+ static DebugLoc getFromDILocation(MDNode *N);
/// isUnknown - Return true if this is an unknown location.
bool isUnknown() const { return ScopeIdx == 0; }
/// DILocation compatible MDNode.
MDNode *getAsMDNode(const LLVMContext &Ctx) const;
- bool operator==(const NewDebugLoc &DL) const {
+ bool operator==(const DebugLoc &DL) const {
return LineCol == DL.LineCol && ScopeIdx == DL.ScopeIdx;
}
- bool operator!=(const NewDebugLoc &DL) const { return !(*this == DL); }
-
-
-
-
- static NewDebugLoc getUnknownLoc() { NewDebugLoc L; return L; }
+ bool operator!=(const DebugLoc &DL) const { return !(*this == DL); }
};
-
- typedef NewDebugLoc DebugLoc;
-
+ typedef DebugLoc NewDebugLoc;
} // end namespace llvm
#endif /* LLVM_DEBUGLOC_H */
/// IRBuilderBase - Common base class shared among various IRBuilders.
class IRBuilderBase {
- NewDebugLoc CurDbgLocation;
+ DebugLoc CurDbgLocation;
protected:
BasicBlock *BB;
BasicBlock::iterator InsertPt;
/// SetCurrentDebugLocation - Set location information used by debugging
/// information.
- void SetCurrentDebugLocation(const NewDebugLoc &L) {
+ void SetCurrentDebugLocation(const DebugLoc &L) {
CurDbgLocation = L;
}
/// getCurrentDebugLocation - Get location information used by debugging
/// information.
- const NewDebugLoc &getCurrentDebugLocation() const { return CurDbgLocation; }
+ const DebugLoc &getCurrentDebugLocation() const { return CurDbgLocation; }
/// SetInstDebugLocation - If this builder has a current debug location, set
/// it on the specified instruction.
namespace llvm {
class MachineFunction;
- class NewDebugLoc; typedef NewDebugLoc DebugLoc;
+ class DebugLoc;
namespace PIC16Dbg {
enum VarType {
T_NULL,
void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L) {
MDNode *Loc = L ? unwrap<MDNode>(L) : NULL;
- unwrap(Builder)->SetCurrentDebugLocation(NewDebugLoc::getFromDILocation(Loc));
+ unwrap(Builder)->SetCurrentDebugLocation(DebugLoc::getFromDILocation(Loc));
}
LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder) {
// DebugLoc Implementation
//===----------------------------------------------------------------------===//
-MDNode *NewDebugLoc::getScope(const LLVMContext &Ctx) const {
+MDNode *DebugLoc::getScope(const LLVMContext &Ctx) const {
if (ScopeIdx == 0) return 0;
if (ScopeIdx > 0) {
return Ctx.pImpl->ScopeInlinedAtRecords[-ScopeIdx-1].first.get();
}
-MDNode *NewDebugLoc::getInlinedAt(const LLVMContext &Ctx) const {
+MDNode *DebugLoc::getInlinedAt(const LLVMContext &Ctx) const {
// Positive ScopeIdx is an index into ScopeRecords, which has no inlined-at
// position specified. Zero is invalid.
if (ScopeIdx >= 0) return 0;
}
/// Return both the Scope and the InlinedAt values.
-void NewDebugLoc::getScopeAndInlinedAt(MDNode *&Scope, MDNode *&IA,
- const LLVMContext &Ctx) const {
+void DebugLoc::getScopeAndInlinedAt(MDNode *&Scope, MDNode *&IA,
+ const LLVMContext &Ctx) const {
if (ScopeIdx == 0) {
Scope = IA = 0;
return;
}
-NewDebugLoc NewDebugLoc::get(unsigned Line, unsigned Col,
- MDNode *Scope, MDNode *InlinedAt) {
- NewDebugLoc Result;
+DebugLoc DebugLoc::get(unsigned Line, unsigned Col,
+ MDNode *Scope, MDNode *InlinedAt) {
+ DebugLoc Result;
// If no scope is available, this is an unknown location.
if (Scope == 0) return Result;
/// getAsMDNode - This method converts the compressed DebugLoc node into a
/// DILocation compatible MDNode.
-MDNode *NewDebugLoc::getAsMDNode(const LLVMContext &Ctx) const {
+MDNode *DebugLoc::getAsMDNode(const LLVMContext &Ctx) const {
if (isUnknown()) return 0;
MDNode *Scope, *IA;
return MDNode::get(Ctx2, &Elts[0], 4);
}
-/// getFromDILocation - Translate the DILocation quad into a NewDebugLoc.
-NewDebugLoc NewDebugLoc::getFromDILocation(MDNode *N) {
- if (N == 0 || N->getNumOperands() != 4) return NewDebugLoc();
+/// getFromDILocation - Translate the DILocation quad into a DebugLoc.
+DebugLoc DebugLoc::getFromDILocation(MDNode *N) {
+ if (N == 0 || N->getNumOperands() != 4) return DebugLoc();
MDNode *Scope = dyn_cast_or_null<MDNode>(N->getOperand(2));
- if (Scope == 0) return NewDebugLoc();
+ if (Scope == 0) return DebugLoc();
unsigned LineNo = 0, ColNo = 0;
if (ConstantInt *Line = dyn_cast_or_null<ConstantInt>(N->getOperand(0)))
}
void Instruction::setDbgMetadata(MDNode *Node) {
- DbgLoc = NewDebugLoc::getFromDILocation(Node);
+ DbgLoc = DebugLoc::getFromDILocation(Node);
}
/// setMetadata - Set the metadata of of the specified kind to the specified
// Handle 'dbg' as a special case since it is not stored in the hash table.
if (KindID == LLVMContext::MD_dbg) {
- DbgLoc = NewDebugLoc::getFromDILocation(Node);
+ DbgLoc = DebugLoc::getFromDILocation(Node);
return;
}
/// removeAllMetadata - Remove all metadata from this instruction.
void Instruction::removeAllMetadata() {
assert(hasMetadata() && "Caller should check");
- DbgLoc = NewDebugLoc();
+ DbgLoc = DebugLoc();
if (hasMetadataHashEntry()) {
getContext().pImpl->MetadataStore.erase(this);
setHasMetadataHashEntry(false);