llvm.org GIT mirror llvm / d0fde30
Put all LLVM code into the llvm namespace, as per bug 109. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@9903 91177308-0d34-0410-b5e6-96231b3b80d8 Brian Gaeke 16 years ago
558 changed file(s) with 2505 addition(s) and 275 deletion(s). Raw diff Collapse all Expand all
1515 dnl * Initialize
1616 dnl **************************************************************************
1717 AC_INIT([[[LLVM]]],[[[1.0]]],[llvmbugs@cs.uiuc.edu])
18 dnl AC_CONFIG_SRC_DIR(lib/VMCore/Pass.cpp)
1819
1920 dnl Place all of the extra autoconf files into the config subdirectory
2021 AC_CONFIG_AUX_DIR([autoconf])
1010 #include "llvm/Constants.h"
1111 #include "llvm/Instructions.h"
1212 #include "llvm/Bytecode/Writer.h"
13
14 using namespace llvm;
1315
1416 int main() {
1517 // Create the "module" or "program" or "translation unit" to hold the
1010 #include "llvm/Constants.h"
1111 #include "llvm/Instructions.h"
1212 #include "llvm/Bytecode/Writer.h"
13
14 using namespace llvm;
1315
1416 int main() {
1517 // Create the "module" or "program" or "translation unit" to hold the
2323
2424 #include
2525 #include
26
27 namespace llvm {
2628
2729 class AnnotationID;
2830 class Annotation;
216218 return A;
217219 }
218220
221 } // End namespace llvm
222
219223 #endif
2828 #include
2929 #include
3030 #include
31
32 namespace llvm {
3133
3234 class BitSetVector {
3335 enum { BITSET_WORDSIZE = sizeof(long)*8 };
265267 return true;
266268 }
267269
270 } // End llvm namespace
268271 #endif
1313
1414 #ifndef SUPPORT_CASTING_H
1515 #define SUPPORT_CASTING_H
16
17 namespace llvm {
1618
1719 //===----------------------------------------------------------------------===//
1820 // isa Support Templates
292294
293295 #endif
294296
297 } // End llvm namespace
298
295299 #endif
2626 #include
2727 #include "boost/type_traits/object_traits.hpp"
2828
29 namespace llvm {
2930 /// cl Namespace - This namespace contains all of the command line option
3031 /// processing machinery. It is intentionally a short name to make qualified
3132 /// usage concise.
10211022
10221023 } // End namespace cl
10231024
1025 } // End namespace llvm
1026
10241027 #endif
1717 #define SUPPORT_DOTGRAPHTRAITS_H
1818
1919 #include
20
21 namespace llvm {
2022
2123 /// DefaultDOTGraphTraits - This class provides the default implementations of
2224 /// all of the DOTGraphTraits methods. If a specialization does not need to
9597 template
9698 class DOTGraphTraits : public DefaultDOTGraphTraits {};
9799
100 } // End llvm namespace
101
98102 #endif
2424
2525 #ifndef SUPPORT_DEBUG_H
2626 #define SUPPORT_DEBUG_H
27
28 namespace llvm {
2729
2830 // DebugFlag - This boolean is set to true if the '-debug' command line option
2931 // is specified. This should probably not be referenced directly, instead, use
5658 do { if (DebugFlag && isCurrentDebugType(DEBUG_TYPE)) { X; } } while (0)
5759 #endif
5860
61 } // End llvm namespace
62
5963 #endif
3636 #include "Support/iterator"
3737 #include
3838 #include
39
40 namespace llvm {
3941
4042 // df_iterator_storage - A private class which is used to figure out where to
4143 // store the visited set.
222224 return idf_ext_iterator::end(G, S);
223225 }
224226
227 } // End llvm namespace
225228
226229 #endif
1717
1818 #include
1919
20 namespace llvm {
21
2022 /// LinkDynamicObject - Load the named file as a dynamic library
2123 /// and link it with the currently running process. Returns false
2224 /// on success, true if there is an error (and sets ErrorMessage
3234 void *GetAddressOfSymbol (const char *symbolName);
3335 void *GetAddressOfSymbol (const std::string &symbolName);
3436
37 } // End llvm namespace
38
3539 #endif // SUPPORT_DYNAMICLINKER_H
1818
1919 #include
2020 #include
21
22 namespace llvm {
2123
2224 template
2325 class EquivalenceClasses {
8890 }
8991 };
9092
93 } // End llvm namespace
94
9195 #endif
1515 #define SUPPORT_FILEUTILITIES_H
1616
1717 #include
18
19 namespace llvm {
1820
1921 /// CheckMagic - Returns true IFF the file named FN begins with Magic. FN must
2022 /// name a readable file.
9496 ///
9597 bool MakeFileReadable (const std::string & Filename);
9698
99 } // End llvm namespace
100
97101 #endif
1616
1717 #ifndef SUPPORT_GRAPHTRAITS_H
1818 #define SUPPORT_GRAPHTRAITS_H
19
20 namespace llvm {
1921
2022 // GraphTraits - This class should be specialized by different graph types...
2123 // which is why the default version is empty.
7577 inline Inverse(GraphType &G) : Graph(G) {}
7678 };
7779
80 } // End llvm namespace
81
7882 #endif
2626 #include "Support/GraphTraits.h"
2727 #include
2828 #include
29
30 namespace llvm {
2931
3032 namespace DOT { // Private functions...
3133 inline std::string EscapeString(const std::string &Label) {
205207 return O;
206208 }
207209
210 } // End llvm namespace
211
208212 #endif
2222 #define SUPPORT_LEAKDETECTOR_H
2323
2424 #include
25
26 namespace llvm {
27
2528 class Value;
2629
2730 struct LeakDetector {
8285 static void checkForGarbageImpl(const std::string &Message);
8386 };
8487
88 } // End llvm namespace
89
8590 #endif
2121
2222 #include
2323 #include
24
25 namespace llvm {
2426
2527 template
2628 struct MallocAllocator {
7880 };
7981 }
8082
83 } // End llvm namespace
8184
8285 #endif
1515
1616 #include "Support/DataTypes.h"
1717
18 namespace llvm {
19
1820 inline unsigned log2(uint64_t C) {
1921 unsigned getPow;
2022 for (getPow = 0; C > 1; ++getPow)
3234 return false;
3335 }
3436
37 } // End llvm namespace
38
3539 #endif
1919 #include "Support/iterator"
2020 #include
2121 #include
22
23 namespace llvm {
2224
2325 template >
2426 class po_iterator : public forward_iterator {
148150 inline rpo_iterator end() { return Blocks.rend(); }
149151 };
150152
153 } // End llvm namespace
154
151155 #endif
2424 #include "Support/iterator"
2525 #include
2626 #include
27
28 namespace llvm {
2729
2830 //===----------------------------------------------------------------------===//
2931 ///
196198 return scc_iterator::end(G);
197199 }
198200
201 } // End llvm namespace
202
199203 #endif
1919 #include
2020 #include "Support/iterator"
2121 #include "boost/type_traits/transform_traits.hpp"
22
23 namespace llvm {
2224
2325 //===----------------------------------------------------------------------===//
2426 // Extra additions to
277279 return tier(f, s);
278280 }
279281
282 } // End llvm namespace
283
280284 #endif
1313
1414 #ifndef SUPPORT_SETOPERATIONS_H
1515 #define SUPPORT_SETOPERATIONS_H
16
17 namespace llvm {
1618
1719 // set_union(A, B) - Compute A := A u B, return whether A changed.
1820 //
6365 S1.erase(*SI);
6466 }
6567
68 } // End llvm namespace
69
6670 #endif
1616
1717 #include
1818
19 namespace llvm {
20
1921 // RemoveFileOnSignal - This function registers signal handlers to ensure that
2022 // if a signal gets delivered that the named file is removed.
2123 //
2224 void RemoveFileOnSignal(const std::string &Filename);
2325
26 } // End llvm namespace
27
2428 #endif
25
2424 #define SUPPORT_STATISTIC_H
2525
2626 #include
27
28 namespace llvm {
2729
2830 // StatisticBase - Nontemplated base class for Statistic<> class...
2931 class StatisticBase {
7779 const Statistic &operator-=(const DataType &V) { Value -= V; return *this; }
7880 };
7981
82 } // End llvm namespace
83
8084 #endif
1616 #include "Support/DataTypes.h"
1717 #include
1818 #include
19
20 namespace llvm {
1921
2022 static inline std::string utohexstr(uint64_t X) {
2123 char Buffer[40];
9496 return Buffer;
9597 }
9698
99 } // End llvm namespace
100
97101 #endif
1515 #define SYSTEMUTILS_H
1616
1717 #include
18
19 namespace llvm {
1820
1921 /// isExecutableFile - This function returns true if the filename specified
2022 /// exists and is executable.
4446 /// wait for it to terminate.
4547 ///
4648 int ExecWait (const char * const argv[], const char * const envp[]);
49
50 } // End llvm namespace
51
4752 #endif
1818 #include
1919 #include
2020 #include
21
22 namespace llvm {
2123
2224 class TimerGroup;
2325
156158 }
157159 };
158160
161 } // End llvm namespace
162
159163 #endif
1515 #define SUPPORT_TREE_H
1616
1717 #include
18
19 namespace llvm {
1820
1921 template
2022 class Tree {
5456 inline const Payload &getTreeData() const { return Data; }
5557 };
5658
59 } // End llvm namespace
5760
5861 #endif
1616 #define SUPPORT_TYPEINFO_H
1717
1818 #include
19
20 namespace llvm {
1921
2022 struct TypeInfo {
2123 TypeInfo() { // needed for containers
6870 return !(lhs < rhs);
6971 }
7072
73 } // End llvm namespace
74
7175 #endif
1616
1717 #include
1818
19 namespace llvm {
20
1921 /// make_vector - Helper function which is useful for building temporary vectors
2022 /// to pass into type construction of CallInst ctors. This turns a null
2123 /// terminated list of pointers (or other value types) into a real live vector.
3234 return Result;
3335 }
3436
37 } // End llvm namespace
38
3539 #endif
3939
4040 #include
4141 #include
42
43 namespace llvm {
4244
4345 template class iplist;
4446 template class ilist_iterator;
521523 void resize(size_type newsize) { resize(newsize, NodeTy()); }
522524 };
523525
526 } // End llvm namespace
527
524528 namespace std {
525529 // Ensure that swap uses the fast list swap...
526530 template
527 void swap(iplist &Left, iplist &Right) {
531 void swap(llvm::iplist &Left, llvm::iplist &Right) {
528532 Left.swap(Right);
529533 }
530534 } // End 'std' extensions...
2828 #include
2929 #include
3030 #include
31
32 namespace llvm {
3133
3234 class BitSetVector {
3335 enum { BITSET_WORDSIZE = sizeof(long)*8 };
265267 return true;
266268 }
267269
270 } // End llvm namespace
268271 #endif
3636 #include "Support/iterator"
3737 #include
3838 #include
39
40 namespace llvm {
3941
4042 // df_iterator_storage - A private class which is used to figure out where to
4143 // store the visited set.
222224 return idf_ext_iterator::end(G, S);
223225 }
224226
227 } // End llvm namespace
225228
226229 #endif
1818
1919 #include
2020 #include
21
22 namespace llvm {
2123
2224 template
2325 class EquivalenceClasses {
8890 }
8991 };
9092
93 } // End llvm namespace
94
9195 #endif
1616
1717 #ifndef SUPPORT_GRAPHTRAITS_H
1818 #define SUPPORT_GRAPHTRAITS_H
19
20 namespace llvm {
1921
2022 // GraphTraits - This class should be specialized by different graph types...
2123 // which is why the default version is empty.
7577 inline Inverse(GraphType &G) : Graph(G) {}
7678 };
7779
80 } // End llvm namespace
81
7882 #endif
1919 #include "Support/iterator"
2020 #include
2121 #include
22
23 namespace llvm {
2224
2325 template >
2426 class po_iterator : public forward_iterator {
148150 inline rpo_iterator end() { return Blocks.rend(); }
149151 };
150152
153 } // End llvm namespace
154
151155 #endif
2424 #include "Support/iterator"
2525 #include
2626 #include
27
28 namespace llvm {
2729
2830 //===----------------------------------------------------------------------===//
2931 ///
196198 return scc_iterator::end(G);
197199 }
198200
201 } // End llvm namespace
202
199203 #endif
1919 #include
2020 #include "Support/iterator"
2121 #include "boost/type_traits/transform_traits.hpp"
22
23 namespace llvm {
2224
2325 //===----------------------------------------------------------------------===//
2426 // Extra additions to
277279 return tier(f, s);
278280 }
279281
282 } // End llvm namespace
283
280284 #endif
1313
1414 #ifndef SUPPORT_SETOPERATIONS_H
1515 #define SUPPORT_SETOPERATIONS_H
16
17 namespace llvm {
1618
1719 // set_union(A, B) - Compute A := A u B, return whether A changed.
1820 //
6365 S1.erase(*SI);
6466 }
6567
68 } // End llvm namespace
69
6670 #endif
2424 #define SUPPORT_STATISTIC_H
2525
2626 #include
27
28 namespace llvm {
2729
2830 // StatisticBase - Nontemplated base class for Statistic<> class...
2931 class StatisticBase {
7779 const Statistic &operator-=(const DataType &V) { Value -= V; return *this; }
7880 };
7981
82 } // End llvm namespace
83
8084 #endif
1616 #include "Support/DataTypes.h"
1717 #include
1818 #include
19
20 namespace llvm {
1921
2022 static inline std::string utohexstr(uint64_t X) {
2123 char Buffer[40];
9496 return Buffer;
9597 }
9698
99 } // End llvm namespace
100
97101 #endif
1515 #define SUPPORT_TREE_H
1616
1717 #include
18
19 namespace llvm {
1820
1921 template
2022 class Tree {
5456 inline const Payload &getTreeData() const { return Data; }
5557 };
5658
59 } // End llvm namespace
5760
5861 #endif
1616
1717 #include
1818
19 namespace llvm {
20
1921 /// make_vector - Helper function which is useful for building temporary vectors
2022 /// to pass into type construction of CallInst ctors. This turns a null
2123 /// terminated list of pointers (or other value types) into a real live vector.
3234 return Result;
3335 }
3436
37 } // End llvm namespace
38
3539 #endif
3939
4040 #include
4141 #include
42
43 namespace llvm {
4244
4345 template class iplist;
4446 template class ilist_iterator;
521523 void resize(size_type newsize) { resize(newsize, NodeTy()); }
522524 };
523525
526 } // End llvm namespace
527
524528 namespace std {
525529 // Ensure that swap uses the fast list swap...
526530 template
527 void swap(iplist &Left, iplist &Right) {
531 void swap(llvm::iplist &Left, llvm::iplist &Right) {
528532 Left.swap(Right);
529533 }
530534 } // End 'std' extensions...
3535 // macro without having to #include directly.
3636 //
3737 #include
38
39 namespace llvm {
3840
3941 class Type;
4042 class DerivedType;
164166 void dropRef();
165167 };
166168
169 } // End llvm namespace
170
167171 #endif
3030 #define LLVM_ANALYSIS_ALIAS_ANALYSIS_H
3131
3232 #include "llvm/Support/CallSite.h"
33
34 namespace llvm {
35
3336 class LoadInst;
3437 class StoreInst;
3538 class TargetData;
155158 const Value *Ptr, unsigned Size);
156159 };
157160
161 } // End llvm namespace
162
158163 #endif
2020 #include "Support/iterator"
2121 #include "Support/hash_map"
2222 #include "Support/ilist"
23
24 namespace llvm {
25
2326 class AliasAnalysis;
2427 class LoadInst;
2528 class StoreInst;
282285 return OS;
283286 }
284287
288 } // End llvm namespace
289
285290 #endif
5050 #include "Support/GraphTraits.h"
5151 #include "Support/STLExtras.h"
5252 #include "llvm/Pass.h"
53
54 namespace llvm {
55
5356 class Function;
5457 class Module;
5558 class CallGraphNode;
287290 static IncludeFile
288291 CALLGRAPH_INCLUDE_FILE((void*)&CallGraph::stub);
289292
293 } // End llvm namespace
294
290295 #endif
1818 #include "llvm/Support/InstIterator.h"
1919 #include "llvm/Instruction.h"
2020 #include "Support/iterator"
21
22 namespace llvm {
23
2124 class Constant;
2225
2326 class constant_iterator : public forward_iterator {
8588 return constant_iterator(F, true);
8689 }
8790
91 } // End llvm namespace
92
8893 #endif
1414 #define LLVM_ANALYSIS_DSGRAPH_H
1515
1616 #include "llvm/Analysis/DSNode.h"
17
18 namespace llvm {
19
1720 class GlobalValue;
1821
1922 //===----------------------------------------------------------------------===//
331334 void removeTriviallyDeadNodes();
332335 };
333336
337 } // End llvm namespace
338
334339 #endif
1919 #include "Support/GraphTraits.h"
2020 #include "Support/iterator"
2121 #include "Support/STLExtras.h"
22
23 namespace llvm {
2224
2325 template
2426 class DSNodeIterator : public forward_iterator {
145147 static ChildIteratorType child_end(const NodeType *N) { return N->end(); }
146148 };
147149
150 } // End llvm namespace
151
148152 #endif
1515
1616 #include "llvm/Analysis/DSSupport.h"
1717
18 namespace llvm {
19
1820 template
1921 class DSNodeIterator; // Data structure graph traversal iterator
2022 class TargetData;
381383 *this = Node;
382384 }
383385
386 } // End llvm namespace
387
384388 #endif
1616 #include
1717 #include "Support/hash_set"
1818 #include "llvm/Support/CallSite.h"
19
20 namespace llvm {
1921
2022 class Function;
2123 class CallInst;
121123 DSNode *HandleForwarding() const;
122124 };
123125
126 } // End llvm namespace
127
124128 namespace std {
125 inline void swap(DSNodeHandle &NH1, DSNodeHandle &NH2) { NH1.swap(NH2); }
129 inline void swap(llvm::DSNodeHandle &NH1, llvm::DSNodeHandle &NH2) { NH1.swap(NH2); }
126130 }
131
132 namespace llvm {
127133
128134 //===----------------------------------------------------------------------===//
129135 /// DSCallSite - Representation of a call site via its call instruction,
286292 }
287293 };
288294
295 } // End llvm namespace
296
289297 namespace std {
290 inline void swap(DSCallSite &CS1, DSCallSite &CS2) { CS1.swap(CS2); }
298 inline void swap(llvm::DSCallSite &CS1, llvm::DSCallSite &CS2) { CS1.swap(CS2); }
291299 }
292300 #endif
1414 #define LLVM_ANALYSIS_DSGRAPH_H
1515
1616 #include "llvm/Analysis/DSNode.h"
17
18 namespace llvm {
19
1720 class GlobalValue;
1821
1922 //===----------------------------------------------------------------------===//
331334 void removeTriviallyDeadNodes();
332335 };
333336
337 } // End llvm namespace
338
334339 #endif
1919 #include "Support/GraphTraits.h"
2020 #include "Support/iterator"
2121 #include "Support/STLExtras.h"
22
23 namespace llvm {
2224
2325 template
2426 class DSNodeIterator : public forward_iterator {
145147 static ChildIteratorType child_end(const NodeType *N) { return N->end(); }
146148 };
147149
150 } // End llvm namespace
151
148152 #endif
1515
1616 #include "llvm/Analysis/DSSupport.h"
1717
18 namespace llvm {
19
1820 template
1921 class DSNodeIterator; // Data structure graph traversal iterator
2022 class TargetData;
381383 *this = Node;
382384 }
383385
386 } // End llvm namespace
387
384388 #endif
1616 #include
1717 #include "Support/hash_set"
1818 #include "llvm/Support/CallSite.h"
19
20 namespace llvm {
1921
2022 class Function;
2123 class CallInst;
121123 DSNode *HandleForwarding() const;
122124 };
123125
126 } // End llvm namespace
127
124128 namespace std {
125 inline void swap(DSNodeHandle &NH1, DSNodeHandle &NH2) { NH1.swap(NH2); }
129 inline void swap(llvm::DSNodeHandle &NH1, llvm::DSNodeHandle &NH2) { NH1.swap(NH2); }
126130 }
131
132 namespace llvm {
127133
128134 //===----------------------------------------------------------------------===//
129135 /// DSCallSite - Representation of a call site via its call instruction,
286292 }
287293 };
288294
295 } // End llvm namespace
296
289297 namespace std {
290 inline void swap(DSCallSite &CS1, DSCallSite &CS2) { CS1.swap(CS2); }
298 inline void swap(llvm::DSCallSite &CS1, llvm::DSCallSite &CS2) { CS1.swap(CS2); }
291299 }
292300 #endif
1616 #include "llvm/Pass.h"
1717 #include "llvm/Target/TargetData.h"
1818 #include "Support/hash_set"
19
20 namespace llvm {
1921
2022 class Type;
2123 class Instruction;
183185 const BUDataStructures::ActualCalleesTy &ActualCallees);
184186 };
185187
188 } // End llvm namespace
189
186190 #endif
1616 #include "llvm/Pass.h"
1717 #include "llvm/Target/TargetData.h"
1818 #include "Support/hash_set"
19
20 namespace llvm {
1921
2022 class Type;
2123 class Instruction;
183185 const BUDataStructures::ActualCalleesTy &ActualCallees);
184186 };
185187
188 } // End llvm namespace
189
186190 #endif
2828 #include
2929 #include
3030 #include
31
32 namespace llvm {
3133
3234 class Instruction;
3335 class Function;
263265
264266 //===----------------------------------------------------------------------===//
265267
268 } // End llvm namespace
269
266270 #endif
2626
2727 #include "llvm/Pass.h"
2828 #include
29
30 namespace llvm {
2931
3032 class Instruction;
3133
486488 const DominatorTree::Node *Node);
487489 };
488490
491 } // End llvm namespace
492
489493 #endif
1515
1616 #ifndef LLVM_ANALYSIS_EXPRESSIONS_H
1717 #define LLVM_ANALYSIS_EXPRESSIONS_H
18
19 namespace llvm {
1820
1921 class Type;
2022 class Value;
5557 const Type *getExprType(const Type *Default) const;
5658 };
5759
60 } // End llvm namespace
61
5862 #endif
2626 #include "llvm/Pass.h"
2727 #include
2828
29 namespace llvm {
30
2931 class PointerType;
3032
3133 struct FindUnsafePointerTypes : public Pass {
5456 }
5557 };
5658
59 } // End llvm namespace
60
5761 #endif
1515
1616 #include "llvm/Pass.h"
1717 #include
18
19 namespace llvm {
20
1821 class Type;
1922
2023 class FindUsedTypes : public Pass {
5861 static IncludeFile
5962 FIND_USED_TYPES_INCLUDE_FILE((void*)&FindUsedTypes::stub);
6063
64 } // End llvm namespace
65
6166 #endif
4848 #include "llvm/Pass.h"
4949 #include "Support/BitSetVector.h"
5050 #include "Support/hash_map"
51
52 namespace llvm {
5153
5254 class Module;
5355 class Function;
238240
239241 //===----------------------------------------------------------------------===//
240242
243 } // End llvm namespace
244
241245 #endif
2626 #define LLVM_ANALYSIS_INDUCTIONVARIABLE_H
2727
2828 #include
29
30 namespace llvm {
31
2932 class Value;
3033 class PHINode;
3134 class Instruction;
5962 void print(std::ostream &OS) const;
6063 };
6164
65 } // End llvm namespace
66
6267 #endif
2323 #include "llvm/Function.h"
2424 #include "Support/Tree.h"
2525 #include
26
27 namespace llvm {
2628
2729 template class InstTreeNode;
2830 template class InstForest;
287289 getTreeData().first.second = InstructionNode;
288290 }
289291
292 } // End llvm namespace
293
290294 #endif
291295
2222 #include "Support/GraphTraits.h"
2323 #include
2424 #include
25
26 namespace llvm {
2527
2628 class BasicBlock;
2729
145147 }
146148 };
147149
150 } // End llvm namespace
151
148152 #endif
3838 #include
3939 #include
4040 #include
41
42 namespace llvm {
4143
4244 // getNodeHeader - Given a source graph node and the source graph, return the
4345 // BasicBlock that is the header node. This is the opposite of
252254 return interval_part_interval_iterator();
253255 }
254256
257 } // End llvm namespace
258
255259 #endif
2424
2525 #include "llvm/Analysis/Interval.h"
2626 #include "llvm/Pass.h"
27
28 namespace llvm {
2729
2830 //===----------------------------------------------------------------------===//
2931 //
101103 void updatePredecessors(Interval *Int);
102104 };
103105
106 } // End llvm namespace
107
104108 #endif
2020 #ifndef LLVM_ANALYSIS_LOAD_VALUE_NUMBERING_H
2121 #define LLVM_ANALYSIS_LOAD_VALUE_NUMBERING_H
2222
23 namespace llvm {
24
2325 class Pass;
2426
2527 /// createLoadValueNumberingPass - Create and return a new pass that implements
2729 ///
2830 Pass *createLoadValueNumberingPass();
2931
32 } // End llvm namespace
33
3034 #endif
2727 #include "llvm/Pass.h"
2828 #include "Support/GraphTraits.h"
2929 #include
30
31 namespace llvm {
3032
3133 class DominatorSet;
3234 class LoopInfo;
223225 }
224226 };
225227
228 } // End llvm namespace
229
226230 #endif
2222 #include "llvm/Analysis/DependenceGraph.h"
2323 #include "llvm/Pass.h"
2424 #include "Support/hash_map"
25
26 namespace llvm {
2527
2628 class ModRefTable;
2729 class DSGraph;
9597 void dump() const;
9698 };
9799
100 } // End llvm namespace
101
98102 #endif
4444 #include "llvm/Instruction.h"
4545 #include "llvm/Pass.h"
4646 #include "Support/iterator"
47
48 namespace llvm {
4749
4850 class DSGraph;
4951 class DependenceGraph;
303305 void dump() const;
304306 };
305307
306
307308 //===----------------------------------------------------------------------===//
308309
310 } // End llvm namespace
311
309312 #endif
1414 #define LLVM_ANALYSIS_POST_DOMINATORS_H
1515
1616 #include "llvm/Analysis/Dominators.h"
17
18 namespace llvm {
1719
1820
1921 /// PostDominatorSet Class - Concrete subclass of DominatorSetBase that is used
116118 static IncludeFile
117119 POST_DOMINATOR_INCLUDE_FILE((void*)&PostDominanceFrontier::stub);
118120
121 } // End llvm namespace
122
119123 #endif
2121
2222 #include
2323 #include
24
25 namespace llvm {
26
2427 class Value;
2528 class Module;
2629 class Function;
9194 void processSymbolTableConstants(const SymbolTable *ST);
9295 };
9396
97 } // End llvm namespace
98
9499 #endif
2020 #define LLVM_ANALYSIS_VALUE_NUMBERING_H
2121
2222 #include
23
24 namespace llvm {
25
2326 class Value;
2427
2528 struct ValueNumbering {
3336 virtual ~ValueNumbering(); // We want to be subclassed
3437 };
3538
39 } // End llvm namespace
40
3641 #endif
2020 #ifndef LLVM_ANALYSIS_VERIFIER_H
2121 #define LLVM_ANALYSIS_VERIFIER_H
2222
23 namespace llvm {
24
2325 class FunctionPass;
2426 class Module;
2527 class Function;
3941 // pass.
4042 bool verifyFunction(const Function &F);
4143
44 } // End llvm namespace
45
4246 #endif
1515 #define LLVM_ARGUMENT_H
1616
1717 #include "llvm/Value.h"
18
19 namespace llvm {
1820
1921 class Argument : public Value { // Defined in the Function.cpp file
2022 Function *Parent;
5557 }
5658 };
5759
60 } // End llvm namespace
61
5862 #endif
1717 #define LLVM_ASSEMBLY_ASMANNOTATIONWRITER_H
1818
1919 #include
20
21 namespace llvm {
22
2023 class Function;
2124 class BasicBlock;
2225 class Instruction;
3639 virtual void emitInstructionAnnot(const Instruction *I, std::ostream &OS) {}
3740 };
3841
42 } // End llvm namespace
43
3944 #endif
1515 #define LLVM_ASSEMBLY_CWRITER_H
1616
1717 #include
18
19 namespace llvm {
20
1821 class Pass;
1922 Pass *createWriteToCPass(std::ostream &o);
2023
24 } // End llvm namespace
25
2126 #endif
1818
1919 #include "llvm/Value.h"
2020 #include
21
22 namespace llvm {
2123
2224 class Module;
2325 class PointerType;
8183 }
8284 };
8385
86 } // End llvm namespace
87
8488 #endif
1414 #define LLVM_ASSEMBLY_PARSER_H
1515
1616 #include
17
18 namespace llvm {
1719
1820 class Module;
1921 class ParseException;
6971 ParseException &operator=(const ParseException &E); // objects by reference
7072 };
7173
74 } // End llvm namespace
75
7276 #endif
1919
2020 #include "llvm/Pass.h"
2121 #include "llvm/Module.h"
22
23 namespace llvm {
2224
2325 class PrintModulePass : public Pass {
2426 std::ostream *Out; // ostream to print on
7173 }
7274 };
7375
76 } // End llvm namespace
77
7478 #endif
2323 #define LLVM_ASSEMBLY_WRITER_H
2424
2525 #include
26
27 namespace llvm {
28
2629 class Type;
2730 class Module;
2831 class Value;
4245 std::ostream &WriteAsOperand(std::ostream &, const Value *, bool PrintTy = true,
4346 bool PrintName = true, const Module *Context = 0);
4447
48 } // End llvm namespace
49
4550 #endif
3131 #include "llvm/Instruction.h"
3232 #include "llvm/SymbolTableListTraits.h"
3333 #include "Support/ilist"
34
35 namespace llvm {
3436
3537 class TerminatorInst;
3638 template class SuccIterator; // Successor Iterator
170172 BasicBlock *splitBasicBlock(iterator I, const std::string &BBName = "");
171173 };
172174
175 } // End llvm namespace
176
173177 #endif
1313
1414 #ifndef LLVM_BYTECODE_FORMAT_H
1515 #define LLVM_BYTECODE_FORMAT_H
16
17 namespace llvm {
1618
1719 class BytecodeFormat { // Throw the constants into a poorman's namespace...
1820 BytecodeFormat(); // do not implement
3739 BasicBlock = 0x31, // May contain many basic blocks
3840 };
3941 };
42
43 } // End llvm namespace
44
4045 #endif
2121 #include "Support/DataTypes.h"
2222 #include
2323 #include
24
25 namespace llvm {
2426
2527 //===----------------------------------------------------------------------===//
2628 // Reading Primitives
274276 if (Align) align32(Out);
275277 }
276278
277 #endif
279 } // End llvm namespace
280
281 #endif
2121 #include "llvm/ModuleProvider.h"
2222 #include
2323 #include
24
25 namespace llvm {
2426
2527 /// getBytecodeModuleProvider - lazy function-at-a-time loading from a file
2628 ///
5254 std::vector &Objects,
5355 std::string *ErrorStr = 0);
5456
57 } // End llvm namespace
58
5559 #endif
1818 #include "llvm/Bytecode/Writer.h"
1919 #include
2020
21 namespace llvm {
22
2123 class WriteBytecodePass : public Pass {
2224 std::ostream *Out; // ostream to print on
2325 bool DeleteStream;
3739 }
3840 };
3941
42 } // End llvm namespace
43
4044 #endif
2525
2626 #include
2727
28 namespace llvm {
29
2830 class Module;
2931 void WriteBytecodeToFile(const Module *C, std::ostream &Out);
3032
33 } // End llvm namespace
34
3135 #endif
2222
2323 #include "llvm/Pass.h"
2424
25 namespace llvm {
26
2527 class CallGraphNode;
2628
2729 struct CallGraphSCCPass : public Pass {
4547 virtual void getAnalysisUsage(AnalysisUsage &Info) const;
4648 };
4749
50 } // End llvm namespace
51
4852 #endif
3737 #include "Support/hash_map"
3838 #include "llvm/Pass.h"
3939 #include "llvm/CodeGen/ValueSet.h"
40
41 namespace llvm {
4042
4143 class BBLiveVar;
4244 class MachineInstr;
103105 const BasicBlock *BB = 0);
104106 };
105107
108 } // End llvm namespace
109
106110 #endif
2828 #include "llvm/Instruction.h"
2929 #include "Support/hash_map"
3030
31 namespace llvm {
32
3133 class Constant;
3234 class Function;
3335 class InstrTreeNode;
3436 class InstrForest;
37
38 } // End llvm namespace
39
40 using namespace llvm;
3541
3642 //--------------------------------------------------------------------------
3743 // OpLabel values for special-case nodes created for instruction selection.
3844 // All op-labels not defined here are identical to the instruction
3945 // opcode returned by Instruction::getOpcode()
4046 //--------------------------------------------------------------------------
47 //
48
4149
4250 const int InvalidOp = -1;
4351 const int VRegListOp = 97;
102110 extern int treecost (InstrTreeNode*, int, int);
103111 extern void printMatches (InstrTreeNode*);
104112
113 namespace llvm {
105114
106115 //------------------------------------------------------------------------
107116 // class InstrTreeNode
324333 InstructionNode* buildTreeForInstruction(Instruction* instr);
325334 };
326335
336 } // End llvm namespace
337
327338 #endif
1414 #ifndef LLVM_CODEGEN_INSTR_SCHEDULING_H
1515 #define LLVM_CODEGEN_INSTR_SCHEDULING_H
1616
17 namespace llvm {
18
1719 class FunctionPass;
1820 class TargetMachine;
1921
2931
3032 FunctionPass *createInstructionSchedulingWithSSAPass(const TargetMachine &TM);
3133
34 } // End llvm namespace
35
3236 #endif
1414 #define LLVM_CODEGEN_INSTR_SELECTION_H
1515
1616 #include "llvm/Instruction.h"
17
18 namespace llvm {
1719
1820 class Function;
1921 class InstrForest;
101103 }
102104 };
103105
106 } // End llvm namespace
107
104108 #endif
1616
1717 #include "llvm/CodeGen/MachineInstr.h"
1818 #include "Support/DataTypes.h"
19
20 namespace llvm {
21
1922 class InstructionNode;
2023 class TargetMachine;
2124 class Instruction;
4346 unsigned& getMachineRegNum,
4447 int64_t& getImmedValue);
4548
49 } // End llvm namespace
50
4651 #endif
3131 #include "llvm/CodeGen/MachineFunctionPass.h"
3232 #include
3333
34 namespace llvm {
35
3436 class MRegisterInfo;
3537
3638 class LiveVariables : public MachineFunctionPass {
206208 void HandlePhysRegDef(unsigned Reg, MachineInstr *MI);
207209 };
208210
211 } // End llvm namespace
212
209213 #endif
1414 #define LLVM_CODEGEN_MACHINEBASICBLOCK_H
1515
1616 #include
17
18 namespace llvm {
19
1720 class BasicBlock;
1821 class MachineInstr;
1922 template struct ilist_traits;
8083 void setNext(MachineBasicBlock *N) { Next = N; }
8184 };
8285
86 } // End llvm namespace
8387
8488 #endif
1818
1919 #include
2020 #include "Support/DataTypes.h"
21
22 namespace llvm {
23
2124 class MachineFunction;
2225 class MachineBasicBlock;
2326 class MachineConstantPool;
104107 static MachineCodeEmitter *createFilePrinterEmitter(MachineCodeEmitter&);
105108 };
106109
110 } // End llvm namespace
111
107112 #endif
2626
2727 #include "Support/Annotation.h"
2828 #include
29
30 namespace llvm {
2931
3032 class MachineInstr;
3133 class Instruction;
9597 CallArgsDescriptor* getCallArgsDescriptor() const { return callArgsDesc; }
9698 };
9799
100 } // End llvm namespace
101
98102 #endif
2222 #define LLVM_CODEGEN_MACHINECONSTANTPOOL_H
2323
2424 #include
25
26 namespace llvm {
27
2528 class Constant;
2629
2730 class MachineConstantPool {
5356 void dump() const;
5457 };
5558
59 } // End llvm namespace
60
5661 #endif
3737 #ifndef LLVM_CODEGEN_MACHINEFRAMEINFO_H
3838 #define LLVM_CODEGEN_MACHINEFRAMEINFO_H
3939
40 namespace llvm {
41
4042 class TargetData;
4143 class TargetRegisterClass;
4244 class Type;
4345 class MachineFunction;
46
47 }
48
4449 #include
50
51 namespace llvm {
4552
4653 class MachineFrameInfo {
4754
219226 void dump(const MachineFunction &MF) const;
220227 };
221228
229 } // End llvm namespace
230
222231 #endif
2020 #include "llvm/CodeGen/MachineBasicBlock.h"
2121 #include "Support/Annotation.h"
2222 #include "Support/ilist"
23
24 namespace llvm {
2325
2426 class Function;
2527 class TargetMachine;
140142 MachineBasicBlock & back() { return BasicBlocks.back(); }
141143 };
142144
145 } // End llvm namespace
146
143147 #endif
1616
1717 #include "Support/HashExtras.h"
1818 #include "Support/hash_set"
19
20 namespace llvm {
21
1922 class MachineFunction;
2023 class Value;
2124 class Constant;
111114 int allocateOptionalArg(const Type* type);
112115 };
113116
117 } // End llvm namespace
118
114119 #endif
2121 #include "llvm/Pass.h"
2222 #include "llvm/CodeGen/MachineFunction.h"
2323
24 namespace llvm {
25
2426 struct MachineFunctionPass : public FunctionPass {
2527
2628 /// runOnMachineFunction - This method must be overloaded to perform the
3638 }
3739 };
3840
41 } // End llvm namespace
42
3943 #endif
1818 #include "llvm/Target/MRegisterInfo.h"
1919 #include "Support/Annotation.h"
2020 #include "Support/iterator"
21
22 namespace llvm {
2123
2224 class Value;
2325 class Function;
714716 std::ostream& operator<<(std::ostream &OS, const MachineOperand &MO);
715717 void PrintMachineInstructions(const Function *F);
716718
719 } // End llvm namespace
720
717721 #endif
1515
1616 #include "llvm/CodeGen/MachineInstr.h"
1717 #include "llvm/Target/TargetRegInfo.h"
18
19 namespace llvm {
1820
1921 class Value;
2022 class TmpInstruction;
8789 static CallArgsDescriptor *get(const MachineInstr* MI);
8890 };
8991
92 } // End llvm namespace
9093
9194 #endif
2323 #define LLVM_CODEGEN_MACHINEINSTRBUILDER_H
2424
2525 #include "llvm/CodeGen/MachineInstr.h"
26
27 namespace llvm {
2628
2729 class MachineInstrBuilder {
2830 MachineInstr *MI;
161163 MOTy::Def);
162164 }
163165
166 } // End llvm namespace
167
164168 #endif
1313
1414 #ifndef LLVM_CODEGEN_PASSES_H
1515 #define LLVM_CODEGEN_PASSES_H
16
17 namespace llvm {
1618
1719 class FunctionPass;
1820 class PassInfo;
5153 /// for the Sparc.
5254 FunctionPass *getRegisterAllocator(TargetMachine &T);
5355
56 } // End llvm namespace
57
5458 #endif
1717 #define LLVM_CODEGEN_SSAREGMAP_H
1818
1919 #include "llvm/Target/MRegisterInfo.h"
20
21 namespace llvm {
2022
2123 class TargetRegisterClass;
2224
4345 }
4446 };
4547
48 } // End llvm namespace
49
4650 #endif
1616
1717 #include "llvm/Value.h"
1818 #include
19
20 namespace llvm {
1921
2022 class SchedGraphEdge;
2123 class SchedGraphNode;
216218 ~SchedGraphCommon();
217219 };
218220
221 } // End llvm namespace
222
219223 #endif
2626 #include
2727 #include
2828 #include
29
30 namespace llvm {
31
2932 class Value;
3033 class Type;
3134 class Instruction;
361364 typedef ReducedValue ReducedValue_Constant_f32;
362365 typedef ReducedValue ReducedValue_Constant_f64;
363366
367 } // End llvm namespace
368
364369 #endif
1616 #define VALUE_SET_H
1717
1818 #include
19
20 namespace llvm {
21
1922 class Value;
2023
2124 // RAV - Used to print values in a form used by the register allocator.
3033 typedef std::set ValueSet;
3134 void printSet(const ValueSet &S);
3235
36 } // End llvm namespace
37
3338 #endif
1414
1515 #ifndef LLVM_CODEGEN_VALUETYPES_H
1616 #define LLVM_CODEGEN_VALUETYPES_H
17
18 namespace llvm {
1719
1820 /// MVT namespace - This namespace defines the ValueType enum, which contains
1921 /// the various low-level value types.
3941 };
4042 };
4143
44 } // End llvm namespace
45
4246 #endif
43
1414 #define LLVM_CONSTANT_H
1515
1616 #include "llvm/User.h"
17
18 namespace llvm {
1719
1820 class Constant : public User {
1921 protected:
9092 // END WARNING!!
9193 };
9294
95 } // End llvm namespace
96
9397 #endif
4141
4242 #include "llvm/Constants.h"
4343 #include "llvm/Type.h"
44
45 namespace llvm {
46
4447 class PointerType;
4548
4649 //===----------------------------------------------------------------------===//
243246 const Constant *V2);
244247 Constant *ConstantFoldGetElementPtr(const Constant *C,
245248 const std::vector &IdxList);
249
250 } // End llvm namespace
251
246252 #endif
1717 #include "llvm/Constant.h"
1818 #include "Support/DataTypes.h"
1919
20 namespace llvm {
21
2022 class ArrayType;
2123 class StructType;
2224 class PointerType;
574576 }
575577 };
576578
579 } // End llvm namespace
580
577581 #endif
1919
2020 #include "llvm/Type.h"
2121 #include
22
23 namespace llvm {
2224
2325 template class TypeMap;
2426 class FunctionValType;
489491 return *const_cast(this) = NewTy;
490492 }
491493
494 } // End llvm namespace
495
492496 #endif
1818 #include
1919 #include
2020 #include
21
22 namespace llvm {
23
2124 class Constant;
2225 class Function;
2326 union GenericValue;
9194 GenericValue LoadValueFromMemory(GenericValue *Ptr, const Type *Ty);
9295 };
9396
97 } // End llvm namespace
98
9499 #endif
1515 #define GENERIC_VALUE_H
1616
1717 #include "Support/DataTypes.h"
18
19 namespace llvm {
1820
1921 typedef uint64_t PointerTy;
2022
4345 inline void* GVTOP(const GenericValue &GV) {
4446 return (void*)(intptr_t)GV.PointerVal;
4547 }
48
49 } // End llvm namespace
4650 #endif
2020 #include "llvm/GlobalValue.h"
2121 #include "llvm/BasicBlock.h"
2222 #include "llvm/Argument.h"
23
24 namespace llvm {
2325
2426 class FunctionType;
2527
9496 virtual bool isExternal() const { return BasicBlocks.empty(); }
9597
9698 /// getIntrinsicID - This method returns the ID number of the specified
97 /// function, or LLVMIntrinsic::not_intrinsic if the function is not an
99 /// function, or Intrinsic::not_intrinsic if the function is not an
98100 /// instrinsic, or if the pointer is null. This value is always defined to be
99101 /// zero to allow easy checking for whether a function is intrinsic or not.
100102 /// The particular intrinsic functions which correspond to this value are
219221 void dropAllReferences();
220222 };
221223
224 } // End llvm namespace
225
222226 #endif
1717 #define LLVM_GLOBALVALUE_H
1818
1919 #include "llvm/User.h"
20
21 namespace llvm {
22
2023 class PointerType;
2124 class Module;
2225
7073 }
7174 };
7275
76 } // End llvm namespace
77
7378 #endif
2020 #define LLVM_GLOBAL_VARIABLE_H
2121
2222 #include "llvm/GlobalValue.h"
23
24 namespace llvm {
2325
2426 class Module;
2527 class Constant;
104106 }
105107 };
106108
109 } // End llvm namespace
110
107111 #endif
1616 #define LLVM_INSTRUCTION_TYPES_H
1717
1818 #include "llvm/Instruction.h"
19
20 namespace llvm {
1921
2022 //===----------------------------------------------------------------------===//
2123 // TerminatorInst Class
133135 }
134136 };
135137
138 } // End llvm namespace
139
136140 #endif
1414
1515 // NOTE: NO INCLUDE GUARD DESIRED!
1616
17 // Provide definitions of macros so that users of this file don't have to define
17 // Provide definitions of macros so that users of this file do not have to define
1818 // everything to use it...
1919 //
2020 #ifndef FIRST_TERM_INST
1515 #define LLVM_INSTRUCTION_H
1616
1717 #include "llvm/User.h"
18
19 namespace llvm {
1820
1921 class AssemblyAnnotationWriter;
2022
150152 };
151153 };
152154
155 } // End llvm namespace
156
153157 #endif
1515 #ifndef LLVM_INTRINSICS_H
1616 #define LLVM_INTRINSICS_H
1717
18 /// LLVMIntrinsic Namespace - This namespace contains an enum with a value for
18 namespace llvm {
19
20 /// Intrinsic Namespace - This namespace contains an enum with a value for
1921 /// every intrinsic/builtin function known by LLVM. These enum values are
2022 /// returned by Function::getIntrinsicID().
2123 ///
22 namespace LLVMIntrinsic {
24 namespace Intrinsic {
2325 enum ID {
2426 not_intrinsic = 0, // Must be zero
2527
124126 // second parameter, the possible values for which are
125127 // defined in the AlphaSfpToSq enumeration
126128 };
127 }
129
130 } // End Intrinsic namespace
131
132 } // End llvm namespace
128133
129134 #endif
1414 #define LLVM_TRANSFORMATIONS_UTILS_LINKER_H
1515
1616 #include
17
18 namespace llvm {
19
1720 class Module;
1821
1922 // LinkModules - This function links two modules together, with the resulting
2326 //
2427 bool LinkModules(Module *Dest, const Module *Src, std::string *ErrorMsg = 0);
2528
29 } // End llvm namespace
30
2631 #endif
2732
2020
2121 #include "llvm/Function.h"
2222 #include "llvm/GlobalVariable.h"
23
24 namespace llvm {
25
2326 class GlobalVariable;
2427 class GlobalValueRefMap; // Used by ConstantVals.cpp
2528 class ConstantPointerRef;
212215 return O;
213216 }
214217
218 } // End llvm namespace
219
215220 #endif
1616
1717 #ifndef MODULEPROVIDER_H
1818 #define MODULEPROVIDER_H
19
20 namespace llvm {
1921
2022 class Function;
2123 class Module;
5153 }
5254 };
5355
56 } // End llvm namespace
57
5458 #endif
3333 #include
3434 #include
3535 #include
36
37 namespace llvm {
38
3639 class Value;
3740 class BasicBlock;
3841 class Function;
328331 virtual void addToPassManager(PassManagerT *PM,AnalysisUsage &AU);
329332 };
330333
334 } // End llvm namespace
335
331336 // Include support files that contain important APIs commonly used by Passes,
332337 // but that we want to separate out to make it easier to read the header files.
333338 //
1717
1818 #ifndef LLVM_PASS_ANALYSIS_SUPPORT_H
1919 #define LLVM_PASS_ANALYSIS_SUPPORT_H
20
21 namespace llvm {
2022
2123 // No need to include Pass.h, we are being included by it!
2224
132134 return dynamic_cast(Resolver->getAnalysisToUpdate(PI));
133135 }
134136
137 } // End llvm namespace
138
135139 #endif
1515
1616 #ifndef LLVM_PASSMANAGER_H
1717 #define LLVM_PASSMANAGER_H
18
19 namespace llvm {
1820
1921 class Pass;
2022 class Module;
7173 bool run(Function &F);
7274 };
7375
76 } // End llvm namespace
77
7478 #endif
2121 #define LLVM_PASS_SUPPORT_H
2222
2323 // No need to include Pass.h, we are being included by it!
24
25 namespace llvm {
2426
2527 class TargetMachine;
2628
394396 struct IncludeFile {
395397 IncludeFile(void *);
396398 };
399
400 } // End llvm namespace
401
397402 #endif
2121
2222 #include
2323 #include
24
25 namespace llvm {
26
2427 class Value;
2528 class Module;
2629 class Function;
9194 void processSymbolTableConstants(const SymbolTable *ST);
9295 };
9396
97 } // End llvm namespace
98
9499 #endif
2323
2424 #include
2525 #include
26
27 namespace llvm {
2628
2729 class AnnotationID;
2830 class Annotation;
216218 return A;
217219 }
218220
221 } // End namespace llvm
222
219223 #endif
1818 #include "llvm/Function.h"
1919 #include "llvm/InstrTypes.h"
2020 #include "Support/iterator"
21
22 namespace llvm {
2123
2224 //===--------------------------------------------------------------------===//
2325 // BasicBlock pred_iterator definition
263265 }
264266 };
265267
268 } // End llvm namespace
269
266270 #endif
2121 #define LLVM_SUPPORT_CALLSITE_H
2222
2323 #include "llvm/Instruction.h"
24
25 namespace llvm {
2426
2527 class CallInst;
2628 class InvokeInst;
99101 }
100102 };
101103
104 } // End llvm namespace
105
102106 #endif
1313
1414 #ifndef SUPPORT_CASTING_H
1515 #define SUPPORT_CASTING_H
16
17 namespace llvm {
1618
1719 //===----------------------------------------------------------------------===//
1820 // isa Support Templates
292294
293295 #endif
294296
297 } // End llvm namespace
298
295299 #endif
2626 #include
2727 #include "boost/type_traits/object_traits.hpp"
2828
29 namespace llvm {
2930 /// cl Namespace - This namespace contains all of the command line option
3031 /// processing machinery. It is intentionally a short name to make qualified
3132 /// usage concise.
10211022
10221023 } // End namespace cl
10231024
1025 } // End namespace llvm
1026
10241027 #endif
2525
2626 #include "Support/DataTypes.h"
2727 #include
28
29 namespace llvm {
30
2831 class ConstantIntegral;
2932 class Type;
3033
123126 return OS;
124127 }
125128
129 } // End llvm namespace
130
126131 #endif
1717 #define SUPPORT_DOTGRAPHTRAITS_H
1818
1919 #include
20
21 namespace llvm {
2022
2123 /// DefaultDOTGraphTraits - This class provides the default implementations of
2224 /// all of the DOTGraphTraits methods. If a specialization does not need to
9597 template
9698 class DOTGraphTraits : public DefaultDOTGraphTraits {};
9799
100 } // End llvm namespace
101
98102 #endif
2424
2525 #ifndef SUPPORT_DEBUG_H
2626 #define SUPPORT_DEBUG_H
27
28 namespace llvm {
2729
2830 // DebugFlag - This boolean is set to true if the '-debug' command line option
2931 // is specified. This should probably not be referenced directly, instead, use
5658 do { if (DebugFlag && isCurrentDebugType(DEBUG_TYPE)) { X; } } while (0)
5759 #endif
5860
61 } // End llvm namespace
62
5963 #endif
1717
1818 #include
1919
20 namespace llvm {
21
2022 /// LinkDynamicObject - Load the named file as a dynamic library
2123 /// and link it with the currently running process. Returns false
2224 /// on success, true if there is an error (and sets ErrorMessage
3234 void *GetAddressOfSymbol (const char *symbolName);
3335 void *GetAddressOfSymbol (const std::string &symbolName);
3436
37 } // End llvm namespace
38
3539 #endif // SUPPORT_DYNAMICLINKER_H
1515 #define SUPPORT_FILEUTILITIES_H
1616
1717 #include
18
19 namespace llvm {
1820
1921 /// CheckMagic - Returns true IFF the file named FN begins with Magic. FN must
2022 /// name a readable file.
9496 ///
9597 bool MakeFileReadable (const std::string & Filename);
9698
99 } // End llvm namespace
100
97101 #endif
2626 #include "Support/GraphTraits.h"
2727 #include
2828 #include
29
30 namespace llvm {
2931
3032 namespace DOT { // Private functions...
3133 inline std::string EscapeString(const std::string &Label) {
205207 return O;
206208 }
207209
210 } // End llvm namespace
211
208212 #endif
2020
2121 #include "llvm/BasicBlock.h"
2222 #include "llvm/Function.h"
23
24 namespace llvm {
2325
2426 // This class implements inst_begin() & inst_end() for
2527 // inst_iterator and const_inst_iterator's.
136138 return const_inst_iterator(F, true);
137139 }
138140
141 } // End llvm namespace
142
139143 #endif
5151
5252 #include "llvm/Instruction.h"
5353
54 namespace llvm {
55
5456 class Module;
5557
5658 // We operate on opaque instruction classes, so forward declare all instruction
6264 // Forward declare the intermediate types...
6365 class TerminatorInst; class BinaryOperator;
6466 class AllocationInst;
65
6667
6768 #define DELEGATE(CLASS_TO_VISIT) \
6869 return ((SubClass*)this)->visit##CLASS_TO_VISIT((CLASS_TO_VISIT&)I)
185186
186187 #undef DELEGATE
187188
189 } // End llvm namespace
190
188191 #endif
2222 #define SUPPORT_LEAKDETECTOR_H
2323
2424 #include
25
26 namespace llvm {
27
2528 class Value;
2629
2730 struct LeakDetector {
8285 static void checkForGarbageImpl(const std::string &Message);
8386 };
8487
88 } // End llvm namespace
89
8590 #endif
1414 #define LLVM_TRANSFORMATIONS_UTILS_LINKER_H
1515
1616 #include
17
18 namespace llvm {
19
1720 class Module;
1821
1922 // LinkModules - This function links two modules together, with the resulting
2326 //
2427 bool LinkModules(Module *Dest, const Module *Src, std::string *ErrorMsg = 0);
2528
29 } // End llvm namespace
30
2631 #endif
2732
2121
2222 #include
2323 #include
24
25 namespace llvm {
2426
2527 template
2628 struct MallocAllocator {
7880 };
7981 }
8082
83 } // End llvm namespace
8184
8285 #endif
1313 #ifndef LLVM_SUPPORT_MANGLER_H
1414 #define LLVM_SUPPORT_MANGLER_H
1515
16 namespace llvm {
17
1618 class Value;
1719 class Module;
20
21 } // End llvm namespace
22
1823 #include
1924 #include
2025 #include
26
27 namespace llvm {
2128
2229 class Mangler {
2330 /// This keeps track of which global values have had their names
5360 static std::string makeNameProper(const std::string &x);
5461 };
5562
63 } // End llvm namespace
64
5665 #endif // LLVM_SUPPORT_MANGLER_H
1515
1616 #include "Support/DataTypes.h"
1717
18 namespace llvm {
19
1820 inline unsigned log2(uint64_t C) {
1921 unsigned getPow;
2022 for (getPow = 0; C > 1; ++getPow)
3234 return false;
3335 }
3436
37 } // End llvm namespace
38
3539 #endif
2626 #include "llvm/Pass.h"
2727 #include
2828 #include
29
30 namespace llvm {
2931
3032 //===----------------------------------------------------------------------===//
3133 // PassNameParser class - Make use of the pass registration mechanism to
113115 }
114116 };
115117
118 } // End llvm namespace
119
116120 #endif
1515 #define SYSTEMUTILS_H
1616
1717 #include
18
19 namespace llvm {
1820
1921 /// isExecutableFile - This function returns true if the filename specified
2022 /// exists and is executable.
4446 /// wait for it to terminate.
4547 ///
4648 int ExecWait (const char * const argv[], const char * const envp[]);
49
50 } // End llvm namespace
51
4752 #endif
1818 #include
1919 #include
2020 #include
21
22 namespace llvm {
2123
2224 class TimerGroup;
2325
156158 }
157159 };
158160
161 } // End llvm namespace
162
159163 #endif
1818
1919 #include "Support/SystemUtils.h"
2020 #include
21
22 namespace llvm {
2123
2224 class CBE;
2325 class LLC;
136138 int OutputAsm(const std::string &Bytecode, std::string &OutputAsmFile);
137139 };
138140
141 } // End llvm namespace
142
139143 #endif
1616 #define SUPPORT_TYPEINFO_H
1717
1818 #include
19
20 namespace llvm {
1921
2022 struct TypeInfo {
2123 TypeInfo() { // needed for containers
6870 return !(lhs < rhs);
6971 }
7072
73 } // End llvm namespace
74
7175 #endif
1818 #define LLVM_SUPPORT_VALUEHOLDER_H
1919
2020 #include "llvm/User.h"
21
22 namespace llvm {
2123
2224 struct ValueHolder : public User {
2325 ValueHolder(Value *V = 0);
4547 }
4648 };
4749
50 } // End llvm namespace
51
4852 #endif
2424
2525 #include "llvm/Value.h"
2626 #include
27
28 namespace llvm {
2729
2830 class SymbolTable : public AbstractTypeUser,
2931 public std::map
131133 virtual void typeBecameConcrete(const DerivedType *AbsTy);
132134 };
133135
136 } // End llvm namespace
137
134138 #endif
2323
2424 #ifndef LLVM_SYMBOLTABLELISTTRAITS_H
2525 #define LLVM_SYMBOLTABLELISTTRAITS_H
26
27 namespace llvm {
2628
2729 template class ilist_iterator;
2830 template class iplist;
7173 void setParent(SymTabClass *Parent); // This is private!
7274 };
7375
76 } // End llvm namespace
77
7478 #endif
1616
1717 #include
1818
19 namespace llvm {
20
1921 // RemoveFileOnSignal - This function registers signal handlers to ensure that
2022 // if a signal gets delivered that the named file is removed.
2123 //
2224 void RemoveFileOnSignal(const std::string &Filename);
2325
26 } // End llvm namespace
27
2428 #endif
25
1818 #include "llvm/CodeGen/MachineBasicBlock.h"
1919 #include
2020
21 namespace llvm {
22
2123 class Type;
2224 class MachineFunction;
2325
279281 MachineBasicBlock &MBB) const = 0;
280282 };
281283
284 } // End llvm namespace
285
282286 #endif
1414 #define LLVM_TARGET_TARGETCACHEINFO_H
1515
1616 #include "Support/DataTypes.h"
17
18 namespace llvm {
1719
1820 class TargetMachine;
1921
5860 }
5961 };
6062
63 } // End llvm namespace
64
6165 #endif
2323 #include "Support/Annotation.h"
2424 #include "Support/DataTypes.h"
2525 #include
26
27 namespace llvm {
28
2629 class Value;
2730 class Type;
2831 class StructType;
100103 inline StructLayout(const StructType *ST, const TargetData &TD);
101104 };
102105
106 } // End llvm namespace
107
103108 #endif
1212
1313 #ifndef LLVM_TARGET_TARGETFRAMEINFO_H
1414 #define LLVM_TARGET_TARGETFRAMEINFO_H
15
16 namespace llvm {
1517
1618 class MachineFunction;
1719
98100 virtual int getDynamicAreaBaseRegNum() const { abort(); }
99101 };
100102
103 } // End llvm namespace
104
101105 #endif
1616 #include "Support/DataTypes.h"
1717 #include
1818 #include
19
20 namespace llvm {
1921
2022 class MachineInstr;
2123 class TargetMachine;
414416 }
415417 };
416418
419 } // End llvm namespace
420
417421 #endif
1515
1616 #include "llvm/Target/TargetData.h"
1717 #include
18
19 namespace llvm {
1820
1921 class TargetInstrInfo;
2022 class TargetInstrDescriptor;
116118 }
117119 };
118120
121 } // End llvm namespace
122
119123 #endif
1414 #ifndef LLVM_TARGET_TARGETMACHINEIMPLS_H
1515 #define LLVM_TARGET_TARGETMACHINEIMPLS_H
1616
17 namespace llvm {
18
1719 class TargetMachine;
1820 class Module;
1921
2931 //
3032 TargetMachine *allocateX86TargetMachine(const Module &M);
3133
34 } // End llvm namespace
35
3236 #endif
1717 #include "Support/hash_map"
1818 #include
1919 #include
20
21 namespace llvm {
2022
2123 class TargetMachine;
2224 class IGNode;
288290 virtual int getSpilledRegSize(int RegType) const = 0;
289291 };
290292
293 } // End llvm namespace
294
291295 #endif
1616 #include "llvm/Target/TargetInstrInfo.h"
1717 #include "Support/hash_map"
1818 #include
19
20 namespace llvm {
1921
2022 typedef long long cycles_t;
2123 static const cycles_t HUGE_LATENCY = ~((long long) 1 << (sizeof(cycles_t)-2));
3537 OpCodePair(); // disable for now
3638 };
3739
40 } // End llvm namespace
41
3842 namespace HASH_NAMESPACE {
39 template <> struct hash {
40 size_t operator()(const OpCodePair& pair) const {
43 template <> struct hash {
44 size_t operator()(const llvm::OpCodePair& pair) const {
4145 return hash()(pair.val);
4246 }
4347 };
44 }
48 } // End HASH_NAMESPACE (a macro) namespace
49
50 namespace llvm {
4551
4652 //---------------------------------------------------------------------------
4753 // class MachineResource
320326
321327 };
322328
329 } // End llvm namespace
330
323331 #endif
1313
1414 #ifndef LLVM_TRANSFORMS_IPO_H
1515 #define LLVM_TRANSFORMS_IPO_H
16
17 namespace llvm {
1618
1719 class Pass;
1820 class Function;
118120 Pass *createSwapElementsPass();
119121 Pass *createSortElementsPass();
120122
123 } // End llvm namespace
124
121125 #endif
1313 #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_H
1414 #define LLVM_TRANSFORMS_INSTRUMENTATION_H
1515
16 namespace llvm {
17
1618 class Pass;
1719
1820 //===----------------------------------------------------------------------===//
2224 Pass *createTraceValuesPassForFunction(); // Just trace function entry/exit
2325 Pass *createTraceValuesPassForBasicBlocks(); // Trace BB's and methods
2426
27 } // End llvm namespace
28
2529 #endif
2222
2323 #include "llvm/Pass.h"
2424 #include "llvm/AbstractTypeUser.h"
25
26 namespace llvm {
2527
2628 class Value;
2729 class Type;
110112 unsigned idx = 0);
111113 };
112114
115 } // End llvm namespace
116
113117 #endif
1313
1414 #ifndef LLVM_TRANSFORMS_SCALAR_H
1515 #define LLVM_TRANSFORMS_SCALAR_H
16
17 namespace llvm {
1618
1719 class Pass;
1820 class FunctionPass;
267269 Pass *createSymbolStrippingPass();
268270 Pass *createFullSymbolStrippingPass();
269271
272 } // End llvm namespace
273
270274 #endif
1818
1919 #include "llvm/BasicBlock.h"
2020 #include "llvm/Support/CFG.h"
21
22 namespace llvm {
23
2124 class Instruction;
2225 class Pass;
2326
4851 // suprising change in program behavior if it is not expected.
4952 //
5053 void RemoveSuccessor(TerminatorInst *TI, unsigned SuccNum);
51
5254
5355 /// isCriticalEdge - Return true if the specified edge is a critical edge.
5456 /// Critical edges are edges from a block with multiple successors to a block
8183 return MadeChange;
8284 }
8385
86 } // End llvm namespace
8487
8588 #endif
1919
2020 #include
2121 #include
22
23 namespace llvm {
24
2225 class Module;
2326 class Function;
2427 class BasicBlock;
108111 /// no jump to it) and returns the new vector of basic blocks.
109112 std::vector CloneTrace(const std::vector &origTrace);
110113
114 } // End llvm namespace
115
111116 #endif
2323 //
2424 //===----------------------------------------------------------------------===//
2525
26 namespace llvm {
27
2628 class Instruction;
2729 class AllocaInst;
2830
2931 AllocaInst *DemoteRegToStack(Instruction &X);
32
33 } // End llvm namespace
1414 #define LLVM_TRANSFORMATIONS_UTILS_LINKER_H
1515
1616 #include
17
18 namespace llvm {
19
1720 class Module;
1821
1922 // LinkModules - This function links two modules together, with the resulting
2326 //
2427 bool LinkModules(Module *Dest, const Module *Src, std::string *ErrorMsg = 0);
2528
29 } // End llvm namespace
30
2631 #endif
2732
1515 #define LLVM_TRANSFORMS_UTILS_LOCAL_H
1616
1717 #include "llvm/Function.h"
18
19 namespace llvm {
20
1821 class Pass;
1922
2023 //===----------------------------------------------------------------------===//
6669 ///
6770 bool SimplifyCFG(BasicBlock *BB);
6871
72 } // End llvm namespace
73
6974 #endif
1414 #ifndef TRANSFORMS_UTILS_PROMOTEMEMTOREG_H
1515 #define TRANSFORMS_UTILS_PROMOTEMEMTOREG_H
1616
17 #include
18
19 namespace llvm {
20
1721 class AllocaInst;
1822 class DominatorTree;
1923 class DominanceFrontier;
2024 class TargetData;
21 #include
2225
2326 /// isAllocaPromotable - Return true if this alloca is legal for promotion.
2427 /// This is true if there are only loads and stores to the alloca...
3437 DominatorTree &DT, DominanceFrontier &DF,
3538 const TargetData &TD);
3639
40 } // End llvm namespace
41
3742 #endif
1919
2020 #include "llvm/Pass.h"
2121
22 namespace llvm {
23
2224 struct UnifyFunctionExitNodes : public FunctionPass {
2325 BasicBlock *ReturnBlock, *UnwindBlock;
2426 public:
3840
3941 Pass *createUnifyFunctionExitNodesPass();
4042
43 } // End llvm namespace
44
4145 #endif
1515 // NOTE: NO INCLUDE GUARD DESIRED!
1616
1717
18 // If the user didn't specify one of the macros, give a default noop defn.
18 // If the user did not specify one of the macros, give a default noop defn.
1919 //
2020 #ifndef HANDLE_PRIM_TYPE
2121 #define HANDLE_PRIM_TYPE(x,y)
3535 #include "llvm/Value.h"
3636 #include "Support/GraphTraits.h"
3737 #include "Support/iterator"
38
39 namespace llvm {
3840
3941 class DerivedType;
4042 class FunctionType;
323325 return Ty.getPrimitiveID() == Type::PointerTyID;
324326 }
325327
328 } // End llvm namespace
329
326330 #endif
1616 #define LLVM_USE_H
1717
1818 #include "Support/ilist"
19
20 namespace llvm {
21
1922 template struct ilist_traits;
2023 class Value;
2124 class User;
7679 };
7780
7881
79 template<> struct simplify_type {
82 template<> struct std::simplify_type {
8083 typedef Value* SimpleType;
8184 static SimpleType getSimplifiedValue(const Use &Val) {
8285 return (SimpleType)Val.get();
8386 }
8487 };
85 template<> struct simplify_type {
88 template<> struct std::simplify_type {
8689 typedef Value* SimpleType;
8790 static SimpleType getSimplifiedValue(const Use &Val) {
8891 return (SimpleType)Val.get();
149152 }
150153 };
151154
155 } // End llvm namespace
156
152157 #endif
2020
2121 #include "llvm/Value.h"
2222 #include
23
24 namespace llvm {
2325
2426 class User : public Value {
2527 User(const User &); // Do not implement
109111 template<> struct simplify_type
110112 : public simplify_type {};
111113
114 } // End llvm namespace
115
112116 #endif
2121 #include "Support/Annotation.h"
2222 #include "Support/Casting.h"
2323 #include
24
25 namespace llvm {
2426
2527 class Type;
2628 class Constant;
197199 return isa(Val) || isa(Val);
198200 }
199201
202 } // End llvm namespace
203
200204 #endif
1515 #define LLVM_IMEMORY_H
1616
1717 #include "llvm/Instruction.h"
18
19 namespace llvm {
20
1821 class PointerType;
1922
2023 //===----------------------------------------------------------------------===//
295298 }
296299 };
297300
301 } // End llvm namespace
302
298303 #endif // LLVM_IMEMORY_H
1414 #define LLVM_IOPERATORS_H
1515
1616 #include "llvm/InstrTypes.h"
17
18 namespace llvm {
1719
1820 /// SetCondInst class - Represent a setCC operator, where CC is eq, ne, lt, gt,
1921 /// le, or ge.
6264 }
6365 };
6466
67 } // End llvm namespace
68
6569 #endif
1515 #define LLVM_IOTHER_H
1616
1717 #include "llvm/InstrTypes.h"
18
19 namespace llvm {
1820
1921 //===----------------------------------------------------------------------===//
2022 // CastInst Class
194196 }
195197 };
196198
199 } // End llvm namespace
200
197201 #endif
1414 #define LLVM_IPHINODE_H
1515
1616 #include "llvm/Instruction.h"
17
18 namespace llvm {
19
1720 class BasicBlock;
1821
1922 //===----------------------------------------------------------------------===//
111114 }
112115 };
113116
117 } // End llvm namespace
118
114119 #endif
1616 #define LLVM_ITERMINATORS_H
1717
1818 #include "llvm/InstrTypes.h"
19
20 namespace llvm {
1921
2022 //===---------------------------------------------------------------------------
2123 // ReturnInst - Return a value (possibly void), from a function. Execution does
305307 }
306308 };
307309
310 } // End llvm namespace
311
308312 #endif
2727 #include "llvm/BasicBlock.h"
2828 #include "llvm/iMemory.h"
2929 #include "llvm/Target/TargetData.h"
30
31 namespace llvm {
3032
3133 // Register the AliasAnalysis interface, providing a nice name to refer to.
3234 namespace {
122124 // Declare that we implement the AliasAnalysis interface
123125 RegisterAnalysisGroup Y;
124126 } // End of anonymous namespace
127
128 } // End llvm namespace
1414 #include "llvm/Analysis/AliasAnalysis.h"
1515 #include "llvm/Pass.h"
1616 #include
17
18 namespace llvm {
1719
1820 namespace {
1921 class AliasAnalysisCounter : public Pass, public AliasAnalysis {
107109 X("count-aa", "Count Alias Analysis Query Responses");
108110 RegisterAnalysisGroup Y;
109111 }
112
113 } // End llvm namespace
2424 #include "llvm/Assembly/Writer.h"
2525 #include "Support/CommandLine.h"
2626 #include
27
28 namespace llvm {
27