Changes in directory llvm/include/llvm:
InlineAsm.h added (r1.1)
Value.h updated: 1.81 -> 1.82
Module.h updated: 1.67 -> 1.68
---
Log message:
Initial checkin of the InlineAsm class
---
Diffs of the changes: (+139 -18)
InlineAsm.h | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Module.h | 65 ++++++++++++++++++++++++++++++++-----------
Value.h | 3 +-
3 files changed, 139 insertions(+), 18 deletions(-)
Index: llvm/include/llvm/InlineAsm.h
diff -c /dev/null llvm/include/llvm/InlineAsm.h:1.1
*** /dev/null Mon Jan 23 22:12:50 2006
--- llvm/include/llvm/InlineAsm.h Mon Jan 23 22:12:40 2006
***************
*** 0 ****
--- 1,89 ----
+ //===-- llvm/InlineAsm.h - Class to represent inline asm strings-*- C++
-*-===//
+ //
+ // The LLVM Compiler Infrastructure
+ //
+ // This file was developed by Chris Lattner and is distributed under
+ // the University of Illinois Open Source License. See LICENSE.TXT for
details.
+ //
+
//===----------------------------------------------------------------------===//
+ //
+ // This class represents the inline asm strings, which are Value*'s that are
+ // used as the callee operand of call instructions.
+ //
+
//===----------------------------------------------------------------------===//
+
+ #ifndef LLVM_INLINEASM_H
+ #define LLVM_INLINEASM_H
+
+ #include "llvm/Value.h"
+
+ namespace llvm {
+
+ class AssemblyAnnotationWriter;
+ class PointerType;
+ class FunctionType;
+ class Module;
+ template<typename SC> struct ilist_traits;
+ template<typename ValueSubClass, typename ItemParentClass, typename
SymTabClass,
+ typename SubClass> class SymbolTableListTraits;
+
+ class InlineAsm : public Value {
+ friend class SymbolTableListTraits<InlineAsm, Module, Module,
+ ilist_traits<InlineAsm> >;
+ InlineAsm(const InlineAsm &); // do not implement
+ void operator=(const InlineAsm&); // do not implement
+
+ void setParent(Module *Parent);
+ InlineAsm *Prev, *Next;
+ void setNext(InlineAsm *N) { Next = N; }
+ void setPrev(InlineAsm *N) { Prev = N; }
+ InlineAsm *getNext() { return Next; }
+ const InlineAsm *getNext() const { return Next; }
+ InlineAsm *getPrev() { return Prev; }
+ const InlineAsm *getPrev() const { return Prev; }
+
+ Module *Parent;
+ std::string AsmString, Constraints;
+ bool AsmHasSideEffects;
+ public:
+ InlineAsm(const FunctionType *Ty, const std::string &AsmString,
+ const std::string &Constraints, bool hasSideEffects,
+ const std::string &Name = "", Module *ParentModule = 0);
+
+ bool getHasSideEffects() const { return AsmHasSideEffects; }
+ void setSideEffects(bool X) { AsmHasSideEffects = X; }
+
+ /// getType - InlineAsm's are always pointers.
+ ///
+ const PointerType *getType() const {
+ return reinterpret_cast<const PointerType*>(Value::getType());
+ }
+
+ /// getFunctionType - InlineAsm's are always pointers to functions.
+ ///
+ const FunctionType *getFunctionType() const;
+
+ /// getParent - Get the module that this global value is contained inside
+ /// of...
+ Module *getParent() { return Parent; }
+ const Module *getParent() const { return Parent; }
+
+
+ /// removeFromParent/eraseFromParent - Unlink and unlink/delete this object
+ /// from the module it is embedded into.
+ void removeFromParent();
+ void eraseFromParent();
+
+ virtual void print(std::ostream &O) const { print(O, 0); }
+ void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
+
+ // Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool classof(const InlineAsm *) { return true; }
+ static inline bool classof(const Value *V) {
+ return V->getValueType() == Value::InlineAsmVal;
+ }
+ };
+
+ } // End llvm namespace
+
+ #endif
Index: llvm/include/llvm/Value.h
diff -u llvm/include/llvm/Value.h:1.81 llvm/include/llvm/Value.h:1.82
--- llvm/include/llvm/Value.h:1.81 Tue Jan 10 03:45:57 2006
+++ llvm/include/llvm/Value.h Mon Jan 23 22:12:40 2006
@@ -155,6 +155,7 @@
ConstantStructVal, // This is an instance of ConstantStruct
ConstantPackedVal, // This is an instance of ConstantPacked
ConstantPointerNullVal, // This is an instance of ConstantPointerNull
+ InlineAsmVal, // This is an instance of InlineAsm
InstructionVal, // This is an instance of Instruction
// Markers:
@@ -166,7 +167,7 @@
}
// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const Value * /*V*/) {
+ static inline bool classof(const Value *) {
return true; // Values are always values.
}
Index: llvm/include/llvm/Module.h
diff -u llvm/include/llvm/Module.h:1.67 llvm/include/llvm/Module.h:1.68
--- llvm/include/llvm/Module.h:1.67 Mon Jan 23 17:02:28 2006
+++ llvm/include/llvm/Module.h Mon Jan 23 22:12:40 2006
@@ -21,6 +21,7 @@
#include "llvm/Function.h"
#include "llvm/GlobalVariable.h"
+#include "llvm/InlineAsm.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/Support/DataTypes.h"
@@ -45,11 +46,19 @@
static void destroySentinel(GlobalVariable *GV) { delete GV; }
static iplist<GlobalVariable> &getList(Module *M);
};
+template<> struct ilist_traits<InlineAsm>
+: public SymbolTableListTraits<InlineAsm, Module, Module> {
+ // createSentinel is used to create a node that marks the end of the list.
+ static InlineAsm *createSentinel();
+ static void destroySentinel(InlineAsm *GV) { delete GV; }
+ static iplist<InlineAsm> &getList(Module *M);
+};
class Module {
public:
typedef iplist<GlobalVariable> GlobalListType;
typedef iplist<Function> FunctionListType;
+ typedef iplist<InlineAsm> InlineAsmListType;
typedef SetVector<std::string> LibraryListType;
// Global Variable iterators.
@@ -60,6 +69,10 @@
typedef FunctionListType::iterator iterator;
typedef FunctionListType::const_iterator const_iterator;
+ // Inline Asm iterators.
+ typedef InlineAsmListType::iterator inlineasm_iterator;
+ typedef InlineAsmListType::const_iterator const_inlineasm_iterator;
+
// Library list iterators.
typedef LibraryListType::const_iterator lib_iterator;
@@ -69,6 +82,7 @@
private:
GlobalListType GlobalList; // The Global Variables in the module
FunctionListType FunctionList; // The Functions in the module
+ InlineAsmListType InlineAsmList; // The inline asm objects in the module.
LibraryListType LibraryList; // The Libraries needed by the module
std::string GlobalScopeAsm; // Inline Asm at global scope.
SymbolTable *SymTab; // Symbol Table for the module
@@ -98,8 +112,8 @@
void setPointerSize(PointerSize PS) { PtrSize = PS; }
// Access to any module-scope inline asm blocks.
- const std::string &getInlineAsm() const { return GlobalScopeAsm; }
- void setInlineAsm(const std::string &Asm) { GlobalScopeAsm = Asm; }
+ const std::string &getModuleInlineAsm() const { return GlobalScopeAsm; }
+ void setModuleInlineAsm(const std::string &Asm) { GlobalScopeAsm = Asm; }
//===--------------------------------------------------------------------===//
// Methods for easy access to the functions in the module.
@@ -174,17 +188,19 @@
// table.
//
- /// Get the underlying elements of the Module...
- inline const GlobalListType &getGlobalList() const { return GlobalList; }
- inline GlobalListType &getGlobalList() { return GlobalList; }
- inline const FunctionListType &getFunctionList() const { return
FunctionList;}
- inline FunctionListType &getFunctionList() { return
FunctionList;}
+ // Get the underlying elements of the Module.
+ const GlobalListType &getGlobalList() const { return GlobalList; }
+ GlobalListType &getGlobalList() { return GlobalList; }
+ const FunctionListType &getFunctionList() const { return FunctionList; }
+ FunctionListType &getFunctionList() { return FunctionList; }
+ const InlineAsmListType &getInlineAsmList() const { return InlineAsmList; }
+ InlineAsmListType &getInlineAsmList() { return InlineAsmList; }
/// getSymbolTable() - Get access to the symbol table for the module, where
/// global variables and functions are identified.
///
- inline SymbolTable &getSymbolTable() { return *SymTab; }
- inline const SymbolTable &getSymbolTable() const { return *SymTab; }
+ SymbolTable &getSymbolTable() { return *SymTab; }
+ const SymbolTable &getSymbolTable() const { return *SymTab; }
//===--------------------------------------------------------------------===//
@@ -198,14 +214,29 @@
bool global_empty() const { return GlobalList.empty(); }
// FunctionList interface
- inline iterator begin() { return FunctionList.begin(); }
- inline const_iterator begin() const { return FunctionList.begin(); }
- inline iterator end () { return FunctionList.end(); }
- inline const_iterator end () const { return FunctionList.end(); }
-
- inline size_t size() const { return FunctionList.size(); }
- inline bool empty() const { return FunctionList.empty(); }
-
+ iterator begin() { return FunctionList.begin(); }
+ const_iterator begin() const { return FunctionList.begin(); }
+ iterator end () { return FunctionList.end(); }
+ const_iterator end () const { return FunctionList.end(); }
+
+ size_t size() const { return FunctionList.size(); }
+ bool empty() const { return FunctionList.empty(); }
+
+ // Inline Asm list interface
+ inlineasm_iterator inlineasm_begin() {
+ return InlineAsmList.begin();
+ }
+ const_inlineasm_iterator inlineasm_begin() const {
+ return InlineAsmList.begin();
+ }
+ inlineasm_iterator inlineasm_end() {
+ return InlineAsmList.end();
+ }
+ const_inlineasm_iterator inlineasm_end() const {
+ return InlineAsmList.end();
+ }
+ bool inlineasm_empty() const { return InlineAsmList.empty(); }
+
//===--------------------------------------------------------------------===//
// List of dependent library access functions
_______________________________________________
llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
