llvm.org GIT mirror llvm / cf0db29
Fixed/added namespace ending comments using clang-tidy. NFC The patch is generated using this command: tools/clang/tools/extra/clang-tidy/tool/run-clang-tidy.py -fix \ -checks=-*,llvm-namespace-comment -header-filter='llvm/.*|clang/.*' \ llvm/lib/ Thanks to Eugene Kosov for the original patch! git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@240137 91177308-0d34-0410-b5e6-96231b3b80d8 Alexander Kornienko 4 years ago
940 changed file(s) with 1172 addition(s) and 1172 deletion(s). Raw diff Collapse all Expand all
18951895 /// Performs a bitwise complement operation on APInt.
18961896 inline APInt Not(const APInt &APIVal) { return ~APIVal; }
18971897
1898 } // End of APIntOps namespace
1898 } // namespace APIntOps
18991899
19001900 // See friend declaration above. This additional declaration is required in
19011901 // order to compile LLVM with IBM xlC compiler.
19021902 hash_code hash_value(const APInt &Arg);
1903 } // End of llvm namespace
1903 } // namespace llvm
19041904
19051905 #endif
360360 template struct isPodLike > {
361361 static const bool value = true;
362362 };
363 }
363 } // namespace llvm
364364
365365 #endif
567567 }
568568 };
569569
570 } // End llvm namespace
570 } // namespace llvm
571571
572572 namespace std {
573573 /// Implement std::swap in terms of BitVector swap.
4141 ValueT &getSecond() { return std::pair::second; }
4242 const ValueT &getSecond() const { return std::pair::second; }
4343 };
44 }
44 } // namespace detail
4545
4646 template <
4747 typename KeyT, typename ValueT, typename KeyInfoT = DenseMapInfo,
3131 DenseSetEmpty &getSecond() { return *this; }
3232 const DenseSetEmpty &getSecond() const { return *this; }
3333 };
34 }
34 } // namespace detail
3535
3636 /// DenseSet - This implements a dense probed hash-table based set.
3737 template >
287287 return make_range(idf_ext_begin(G, S), idf_ext_end(G, S));
288288 }
289289
290 } // End llvm namespace
290 } // namespace llvm
291291
292292 #endif
277277 };
278278 };
279279
280 } // End llvm namespace
280 } // namespace llvm
281281
282282 #endif
100100 }
101101 };
102102
103 } // End llvm namespace
103 } // namespace llvm
104104
105105 #endif
7979 }
8080 };
8181
82 } // End llvm namespace
82 } // namespace llvm
8383
8484 #endif
8282 void uncompress();
8383 };
8484
85 } // End llvm namespace
85 } // namespace llvm
8686
8787 #endif
203203 template
204204 void operator>(const Optional &X, const Optional &Y);
205205
206 } // end llvm namespace
206 } // namespace llvm
207207
208208 #endif
506506 RHS.template get()));
507507 }
508508 };
509 }
509 } // namespace llvm
510510
511511 #endif
294294 rpo_iterator end() { return Blocks.rend(); }
295295 };
296296
297 } // End llvm namespace
297 } // namespace llvm
298298
299299 #endif
7878 }
7979 };
8080
81 } // End llvm namespace
81 } // namespace llvm
8282
8383 #endif
239239 return scc_iterator >::end(G);
240240 }
241241
242 } // End llvm namespace
242 } // namespace llvm
243243
244244 #endif
416416 }
417417 };
418418
419 } // End llvm namespace
419 } // namespace llvm
420420
421421 #endif
6565 S1.erase(*SI);
6666 }
6767
68 } // End llvm namespace
68 } // namespace llvm
6969
7070 #endif
224224 }
225225 };
226226
227 } // End llvm namespace
227 } // namespace llvm
228228
229229 // vim: sw=2 ai
230230 #endif
587587 return Result;
588588 }
589589
590 } // End llvm namespace
590 } // namespace llvm
591591
592592 namespace std {
593593 /// Implement std::swap in terms of BitVector swap.
333333 }
334334 };
335335
336 }
336 } // namespace llvm
337337
338338 namespace std {
339339 /// Implement std::swap in terms of SmallPtrSet swap.
291291 }
292292 };
293293
294 }
294 } // namespace llvm
295295
296296 #endif
923923 return X.capacity_in_bytes();
924924 }
925925
926 } // End llvm namespace
926 } // namespace llvm
927927
928928 namespace std {
929929 /// Implement std::swap in terms of SmallVector swap.
939939 swap(llvm::SmallVector &LHS, llvm::SmallVector &RHS) {
940940 LHS.swap(RHS);
941941 }
942 }
942 } // namespace std
943943
944944 #endif
175175 /// \brief Print statistics to the given output stream.
176176 void PrintStatistics(raw_ostream &OS);
177177
178 } // End llvm namespace
178 } // namespace llvm
179179
180180 #endif
206206 return join_impl(Begin, End, Separator, tag());
207207 }
208208
209 } // End llvm namespace
209 } // namespace llvm
210210
211211 #endif
446446 }
447447 };
448448
449 }
449 } // namespace llvm
450450
451451 #endif
565565 // StringRefs can be treated like a POD type.
566566 template struct isPodLike;
567567 template <> struct isPodLike { static const bool value = true; };
568 }
568 } // namespace llvm
569569
570570 #endif
2828 return base::insert(std::make_pair(Key, '\0'));
2929 }
3030 };
31 }
31 } // namespace llvm
3232
3333 #endif // LLVM_ADT_STRINGSET_H
608608 /// @}
609609 };
610610
611 } // End llvm namespace
611 } // namespace llvm
612612
613613
614614 #endif
536536 }
537537
538538 /// @}
539 }
539 } // namespace llvm
540540
541541 #endif
9696 return Result;
9797 }
9898
99 } // End llvm namespace
99 } // namespace llvm
100100
101101 #endif
654654 void resize(size_type newsize) { resize(newsize, NodeTy()); }
655655 };
656656
657 } // End llvm namespace
657 } // namespace llvm
658658
659659 namespace std {
660660 // Ensure that swap uses the fast list swap...
100100 /// @}
101101 };
102102
103 } // End llvm namespace
103 } // namespace llvm
104104
105105 #endif
238238 T &operator*() const { return **this->I; }
239239 };
240240
241 }
241 } // namespace llvm
242242
243243 #endif
5050 template iterator_range make_range(std::pair p) {
5151 return iterator_range(std::move(p.first), std::move(p.second));
5252 }
53 }
53 } // namespace llvm
5454
5555 #endif
557557 /// IdentifiedObjects.
558558 bool isIdentifiedFunctionLocal(const Value *V);
559559
560 } // End llvm namespace
560 } // namespace llvm
561561
562562 #endif
436436 return OS;
437437 }
438438
439 } // End llvm namespace
439 } // namespace llvm
440440
441441 #endif
6262
6363 };
6464
65 }
65 } // namespace llvm
6666
6767 #endif
627627 else
628628 addBlockEdges(*this, Irr, OuterLoop);
629629 }
630 }
630 } // namespace bfi_detail
631631
632632 /// \brief Shared implementation for block frequency analysis.
633633 ///
11321132 G.addEdge(Irr, BFI.getNode(*I), OuterLoop);
11331133 }
11341134 };
1135 }
1135 } // namespace bfi_detail
11361136 template
11371137 void BlockFrequencyInfoImpl::computeIrreducibleMass(
11381138 LoopData *OuterLoop, std::list::iterator Insert) {
157157 bool calcInvokeHeuristics(BasicBlock *BB);
158158 };
159159
160 }
160 } // namespace llvm
161161
162162 #endif
7777 const DominatorTree *DT = nullptr,
7878 const LoopInfo *LI = nullptr);
7979
80 } // End llvm namespace
80 } // namespace llvm
8181
8282 #endif
118118 return "";
119119 }
120120 };
121 } // End llvm namespace
121 } // namespace llvm
122122
123123 namespace llvm {
124124 class FunctionPass;
484484 createCGSCCToFunctionPassAdaptor(FunctionPassT Pass) {
485485 return CGSCCToFunctionPassAdaptor(std::move(Pass));
486486 }
487 }
487 } // namespace llvm
488488
489489 #endif
480480 static const CallGraphNode &CGdereference(PairTy P) { return *P.second; }
481481 };
482482
483 } // End llvm namespace
483 } // namespace llvm
484484
485485 #endif
101101 iterator end() const { return Nodes.end(); }
102102 };
103103
104 } // End llvm namespace
104 } // namespace llvm
105105
106106 #endif
101101 SmallPtrSetImpl &EphValues);
102102 };
103103
104 }
104 } // namespace llvm
105105
106106 #endif
9696 /// with the specified arguments, returning null if unsuccessful.
9797 Constant *ConstantFoldCall(Function *F, ArrayRef Operands,
9898 const TargetLibraryInfo *TLI = nullptr);
99 }
99 } // namespace llvm
100100
101101 #endif
2424 FunctionPass *createPostDomOnlyPrinterPass();
2525 FunctionPass *createPostDomViewerPass();
2626 FunctionPass *createPostDomOnlyViewerPass();
27 } // End llvm namespace
27 } // namespace llvm
2828
2929 #endif
204204 EXTERN_TEMPLATE_INSTANTIATION(class DominanceFrontierBase);
205205 EXTERN_TEMPLATE_INSTANTIATION(class ForwardDominanceFrontierBase);
206206
207 } // End llvm namespace
207 } // namespace llvm
208208
209209 #endif
220220 return *Result;
221221 }
222222
223 } // End llvm namespace
223 } // namespace llvm
224224
225225 #endif
177177
178178 Pass *createIVUsersPass();
179179
180 }
180 } // namespace llvm
181181
182182 #endif
3535 /// Do not inline functions which allocate this many bytes on the stack
3636 /// when the caller is recursive.
3737 const unsigned TotalAllocaSizeRecursiveCaller = 1024;
38 }
38 } // namespace InlineConstants
3939
4040 /// \brief Represents the cost of inlining a function.
4141 ///
137137 bool isInlineViable(Function &Callee);
138138 };
139139
140 }
140 } // namespace llvm
141141
142142 #endif
144144 }
145145 };
146146
147 } // End llvm namespace
147 } // namespace llvm
148148
149149 #endif
262262 return interval_part_interval_iterator();
263263 }
264264
265 } // End llvm namespace
265 } // namespace llvm
266266
267267 #endif
105105 void updatePredecessors(Interval *Int);
106106 };
107107
108 } // End llvm namespace
108 } // namespace llvm
109109
110110 #endif
9191 const SmallPtrSetImpl *DefBlocks;
9292 SmallVector PHIBlocks;
9393 };
94 }
94 } // namespace llvm
9595 #endif
6565 /// bound specifies the maximum number of bytes needed to represent an
6666 /// unconditional jump or a trap instruction in the back end currently in use.
6767 ModulePass *createJumpInstrTableInfoPass(unsigned Bound);
68 }
68 } // namespace llvm
6969
7070 #endif /* LLVM_ANALYSIS_JUMPINSTRTABLEINFO_H */
568568 static StringRef name() { return "LazyCallGraphPrinterPass"; }
569569 };
570570
571 }
571 } // namespace llvm
572572
573573 #endif
6565 ImmutableCallSite CS,
6666 const MemoryLocation &Loc);
6767 };
68 } // End of llvm namespace
68 } // namespace llvm
6969
7070 #endif
4343 const Function &F ///< The function to be checked
4444 );
4545
46 } // End llvm namespace
46 } // namespace llvm
4747
4848 #endif
5151 AliasAnalysis *AA = nullptr,
5252 AAMDNodes *AATags = nullptr);
5353
54 }
54 } // namespace llvm
5555
5656 #endif
554554 DominatorTree *DT;
555555 LoopInfo *LI;
556556 };
557 } // End llvm namespace
557 } // namespace llvm
558558
559559 #endif
762762 void getAnalysisUsage(AnalysisUsage &AU) const override;
763763 };
764764
765 } // End llvm namespace
765 } // namespace llvm
766766
767767 #endif
534534 #endif
535535 }
536536
537 } // End llvm namespace
537 } // namespace llvm
538538
539539 #endif
168168 Loop *CurrentLoop;
169169 };
170170
171 } // End llvm namespace
171 } // namespace llvm
172172
173173 #endif
261261 SizeOffsetEvalType visitInstruction(Instruction &I);
262262 };
263263
264 } // End llvm namespace
264 } // namespace llvm
265265
266266 #endif
444444
445445 };
446446
447 } // End llvm namespace
447 } // namespace llvm
448448
449449 #endif
136136 return LHS == RHS;
137137 }
138138 };
139 }
139 } // namespace llvm
140140
141141 #endif
172172 //
173173 FunctionPass *createMemDerefPrinter();
174174
175 }
175 } // namespace llvm
176176
177177 #endif
111111 }
112112 };
113113
114 } // End llvm namespace
114 } // namespace llvm
115115
116116 #endif
905905 EXTERN_TEMPLATE_INSTANTIATION(class RegionNodeBase>);
906906 EXTERN_TEMPLATE_INSTANTIATION(class RegionInfoBase>);
907907
908 } // End llvm namespace
908 } // namespace llvm
909909 #endif
122122 }
123123 };
124124
125 } // End llvm namespace
125 } // namespace llvm
126126
127127 #endif
980980 /// to locate them all and call their destructors.
981981 SCEVUnknown *FirstUnknown;
982982 };
983 }
983 } // namespace llvm
984984
985985 #endif
274274 Value *expandIVInc(PHINode *PN, Value *StepV, const Loop *L,
275275 Type *ExpandTy, Type *IntTy, bool useSubtract);
276276 };
277 }
278
279 #endif
277 } // namespace llvm
278
279 #endif
828828 return SCEVApplyRewriter::rewrite(Scev, Map, SE);
829829 }
830830
831 }
831 } // namespace llvm
832832
833833 #endif
7272 ScalarEvolution &SE,
7373 DominatorTree &DT);
7474
75 }
75 } // namespace llvm
7676
7777 #endif
264264 }
265265 };
266266
267 }
267 } // namespace llvm
268268
269269 #endif
907907 /// clients.
908908 ImmutablePass *createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA);
909909
910 } // End llvm namespace
910 } // namespace llvm
911911
912912 #endif
445445 U->getNumOperands() == 1 ? U->getOperand(0)->getType() : nullptr);
446446 }
447447 };
448 }
448 } // namespace llvm
449449
450450 #endif
6666 /// @return true on error.
6767 bool parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err);
6868
69 } // End llvm namespace
69 } // namespace llvm
7070
7171 #endif
7676 // [id, name]
7777 };
7878
79 } // End bitc namespace
79 } // namespace bitc
8080
8181 /// BitCodeAbbrevOp - This describes one or more operands in an abbreviation.
8282 /// This is actually a union of two different things:
179179 OperandList.push_back(OpInfo);
180180 }
181181 };
182 } // End llvm namespace
182 } // namespace llvm
183183
184184 #endif
5555 static StringRef name() { return "BitcodeWriterPass"; }
5656 };
5757
58 }
58 } // namespace llvm
5959
6060 #endif
511511 bool ReadBlockInfoBlock();
512512 };
513513
514 } // End llvm namespace
514 } // namespace llvm
515515
516516 #endif
519519 };
520520
521521
522 } // End llvm namespace
522 } // namespace llvm
523523
524524 #endif
415415 COMDAT_SELECTION_KIND_SAME_SIZE = 5,
416416 };
417417
418 } // End bitc namespace
419 } // End llvm namespace
418 } // namespace bitc
419 } // namespace llvm
420420
421421 #endif
165165 }
166166 };
167167
168 } // End llvm namespace
168 } // namespace llvm
169169
170170 namespace std {
171171 template <> struct is_error_code_enum : std::true_type {};
114114 // or we are in LTO.
115115 bool canBeOmittedFromSymbolTable(const GlobalValue *GV);
116116
117 } // End llvm namespace
117 } // namespace llvm
118118
119119 #endif
534534 void EmitXXStructorList(const Constant *List, bool isCtor);
535535 GCMetadataPrinter *GetOrCreateGCPrinter(GCStrategy &C);
536536 };
537 }
537 } // namespace llvm
538538
539539 #endif
829829 }
830830 };
831831
832 }
832 } // namespace llvm
833833
834834 #endif
7373 const MachineBlockFrequencyInfo &MBFI,
7474 VirtRegAuxInfo::NormalizingFn norm =
7575 normalizeSpillWeight);
76 }
76 } // namespace llvm
7777
7878 #endif // LLVM_CODEGEN_CALCSPILLWEIGHTS_H
158158 }
159159
160160 };
161 }
161 } // namespace llvm
162162
163163 #endif
634634 #endif
635635 };
636636
637 } // end llvm namespace
638
639 #endif
637 } // namespace llvm
638
639 #endif
6767
6868 void emitFunctionInfo(const MCSymbol *FnLabel, const FunctionFaultInfos &FFI);
6969 };
70 }
70 } // namespace llvm
7171
7272 #endif
200200 /// will soon change.
201201 GCFunctionInfo &getFunctionInfo(const Function &F);
202202 };
203 }
203 } // namespace llvm
204204
205205 #endif
5858
5959 virtual ~GCMetadataPrinter();
6060 };
61 }
61 } // namespace llvm
6262
6363 #endif
171171 /// register your GCMetadataPrinter subclass with the
172172 /// GCMetadataPrinterRegistery as well.
173173 typedef Registry GCRegistry;
174 }
174 } // namespace llvm
175175
176176 #endif
4040 void linkShadowStackGC();
4141
4242 void linkStatepointExampleGC();
43 }
43 } // namespace llvm
4444
4545 #endif
889889 CVT_INVALID /// Marker - Invalid opcode
890890 };
891891
892 } // end llvm::ISD namespace
893
894 } // end llvm namespace
892 } // namespace ISD
893
894 } // namespace llvm
895895
896896 #endif
5353 /// simple integer bswap.
5454 static bool LowerToByteSwap(CallInst *CI);
5555 };
56 }
56 } // namespace llvm
5757
5858 #endif
9292 void AdjustPriorityOfUnscheduledPreds(SUnit *SU);
9393 SUnit *getSingleUnscheduledPred(SUnit *SU);
9494 };
95 }
95 } // namespace llvm
9696
9797 #endif
251251 LexicalScope *CurrentFnLexicalScope;
252252 };
253253
254 } // end llvm namespace
254 } // namespace llvm
255255
256256 #endif
865865
866866 };
867867
868 }
868 } // namespace llvm
869869 #endif
443443
444444 class HMEditor;
445445 };
446 } // End llvm namespace
446 } // namespace llvm
447447
448448 #endif
227227 const MachineBlockFrequencyInfo&);
228228 };
229229
230 }
230 } // namespace llvm
231231
232232 #endif
9494 /// print - Implement the dump method.
9595 void print(raw_ostream &O, const Module* = nullptr) const override;
9696 };
97 }
97 } // namespace llvm
9898
9999 #endif /* LLVM_CODEGEN_LIVESTACK_ANALYSIS_H */
305305 void setPHIJoin(unsigned Reg) { PHIJoins.set(Reg); }
306306 };
307307
308 } // End llvm namespace
308 } // namespace llvm
309309
310310 #endif
800800 MachineBasicBlock::iterator getInitial() { return I; }
801801 };
802802
803 } // End llvm namespace
803 } // namespace llvm
804804
805805 #endif
8383 const MachineBasicBlock *Dst) const;
8484 };
8585
86 }
86 } // namespace llvm
8787
8888
8989 #endif
173173 void dump() const;
174174 };
175175
176 } // End llvm namespace
176 } // namespace llvm
177177
178178 #endif
103103 void getAnalysisUsage(AnalysisUsage &AU) const override;
104104 };
105105
106 }
106 } // namespace llvm
107107
108108 #endif
599599 void dump(const MachineFunction &MF) const;
600600 };
601601
602 } // End llvm namespace
602 } // namespace llvm
603603
604604 #endif
545545 }
546546 };
547547
548 } // End llvm namespace
548 } // namespace llvm
549549
550550 #endif
4949 void getAnalysisUsage(AnalysisUsage &AU) const override;
5050 };
5151
52 } // End llvm namespace
52 } // namespace llvm
5353
5454 #endif
5353 bool runOnFunction(Function &F) override;
5454 };
5555
56 } // End llvm namespace
56 } // namespace llvm
5757
5858 #endif
12341234 return OS;
12351235 }
12361236
1237 } // End llvm namespace
1237 } // namespace llvm
12381238
12391239 #endif
3939 ImplicitDefine = Implicit | Define,
4040 ImplicitKill = Implicit | Kill
4141 };
42 }
42 } // namespace RegState
4343
4444 class MachineInstrBuilder {
4545 MachineFunction *MF;
501501 }
502502 };
503503
504 } // End llvm namespace
504 } // namespace llvm
505505
506506 #endif
246246 const MachineOperand *operator->() const { return &deref(); }
247247 };
248248
249 } // End llvm namespace
249 } // namespace llvm
250250
251251 #endif
124124 void dump() const;
125125 };
126126
127 } // End llvm namespace
127 } // namespace llvm
128128
129129 #endif
185185 }
186186 };
187187
188 } // End llvm namespace
188 } // namespace llvm
189189
190190 #endif
220220
221221 raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MRO);
222222
223 } // End llvm namespace
223 } // namespace llvm
224224
225225 #endif
440440
441441 }; // End class MachineModuleInfo
442442
443 } // End llvm namespace
443 } // namespace llvm
444444
445445 #endif
740740 // See friend declaration above. This additional declaration is required in
741741 // order to compile LLVM with IBM xlC compiler.
742742 hash_code hash_value(const MachineOperand &MO);
743 } // End llvm namespace
743 } // namespace llvm
744744
745745 #endif
175175 EXTERN_TEMPLATE_INSTANTIATION(class RegionNodeBase>);
176176 EXTERN_TEMPLATE_INSTANTIATION(class RegionInfoBase>);
177177
178 }
178 } // namespace llvm
179179
180180 #endif
10351035 return PSetIterator(RegUnit, this);
10361036 }
10371037
1038 } // End llvm namespace
1038 } // namespace llvm
10391039
10401040 #endif
110110 MachineSSAUpdater(const MachineSSAUpdater&) = delete;
111111 };
112112
113 } // End llvm namespace
113 } // namespace llvm
114114
115115 #endif
643643 /// @}
644644 };
645645
646 } // End llvm namespace
646 } // namespace llvm
647647
648648 #endif
6363 void anchor() override;
6464 };
6565
66 }
66 } // namespace llvm
6767
6868 #endif /* LLVM_CODEGEN_PBQPRACONSTRAINT_H */
636636 /// createForwardControlFlowIntegrityPass - This pass adds control-flow
637637 /// integrity.
638638 ModulePass *createForwardControlFlowIntegrityPass();
639 } // End llvm namespace
639 } // namespace llvm
640640
641641 /// Target machine pass initializer for passes with dependencies. Use with
642642 /// INITIALIZE_TM_PASS_END.
105105
106106 int getFrameIndex() const { return FI; }
107107 };
108 } // End llvm namespace
108 } // namespace llvm
109109
110110 #endif
183183
184184 };
185185
186 } // End llvm namespace
186 } // namespace llvm
187187
188188 #endif
130130 unsigned numberRCValPredInSU (SUnit *SU, unsigned RCId);
131131 unsigned numberRCValSuccInSU (SUnit *SU, unsigned RCId);
132132 };
133 }
133 } // namespace llvm
134134
135135 #endif
428428 /// Return the SYNC_FETCH_AND_* value for the given opcode and type, or
429429 /// UNKNOWN_LIBCALL if there is none.
430430 Libcall getATOMIC(unsigned Opc, MVT VT);
431 }
432 }
431 } // namespace RTLIB
432 } // namespace llvm
433433
434434 #endif
747747 reverse_iterator rend() { return Index2Node.rend(); }
748748 const_reverse_iterator rend() const { return Index2Node.rend(); }
749749 };
750 }
750 } // namespace llvm
751751
752752 #endif
120120 void RecedeCycle() override;
121121 };
122122
123 }
123 } // namespace llvm
124124
125125 #endif //!LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H
300300
301301 };
302302
303 }
303 } // namespace llvm
304304
305305 #endif /* LLVM_CODEGEN_SELECTIONDAGISEL_H */
8888 /// Return true if the node has at least one operand
8989 /// and all operands of the specified node are ISD::UNDEF.
9090 bool allOperandsUndef(const SDNode *N);
91 } // end llvm:ISD namespace
91 } // namespace ISD
9292
9393 //===----------------------------------------------------------------------===//
9494 /// Unlike LLVM values, Selection DAG nodes may return multiple
22672267 return isa(N) &&
22682268 cast(N)->getAddressingMode() == ISD::UNINDEXED;
22692269 }
2270 }
2271
2272 } // end llvm namespace
2270 } // namespace ISD
2271
2272 } // namespace llvm
22732273
22742274 #endif
704704 struct IntervalMapInfo : IntervalMapHalfOpenInfo {
705705 };
706706
707 }
707 } // namespace llvm
708708
709709 #endif // LLVM_CODEGEN_SLOTINDEXES_H
254254 void debug() { print(dbgs()); }
255255 };
256256
257 }
257 } // namespace llvm
258258
259259 #endif
360360 unsigned getExtendedSizeInBits() const;
361361 };
362362
363 } // End llvm namespace
363 } // namespace llvm
364364
365365 #endif
184184 VRM.print(OS);
185185 return OS;
186186 }
187 } // End llvm namespace
187 } // namespace llvm
188188
189189 #endif
160160 void calculateWinCXXEHStateNumbers(const Function *ParentFn,
161161 WinEHFuncInfo &FuncInfo);
162162
163 }
163 } // namespace llvm
164164 #endif // LLVM_CODEGEN_WINEHFUNCINFO_H
171171 virtual std::unique_ptr clone() const = 0;
172172 };
173173
174 }
174 } // namespace llvm
175175
176176 #endif
5656 AttributeSpecVector AttributeSpecs;
5757 };
5858
59 }
59 } // namespace llvm
6060
6161 #endif
4848 void dump(raw_ostream &OS) const;
4949 };
5050
51 }
51 } // namespace llvm
5252
5353 #endif
2525 ~DWARFCompileUnit() override;
2626 };
2727
28 }
28 } // namespace llvm
2929
3030 #endif
5757 void clear();
5858 };
5959
60 }
60 } // namespace llvm
6161
6262 #endif
8181 DenseSet ParsedCUOffsets;
8282 };
8383
84 }
84 } // namespace llvm
8585
8686 #endif
154154 const DWARFUnit *U;
155155 };
156156
157 }
157 } // namespace llvm
158158
159159 #endif
247247 LineTableMapTy LineTableMap;
248248 };
249249
250 }
250 } // namespace llvm
251251
252252 #endif
7575 void parse(DataExtractor data);
7676 void dump(raw_ostream &OS) const;
7777 };
78 }
78 } // namespace llvm
7979
8080 #endif
9090 void dumpString(raw_ostream &OS, const DWARFUnit *U) const;
9191 };
9292
93 }
93 } // namespace llvm
9494
9595 #endif
3131 bool extractImpl(DataExtractor debug_info, uint32_t *offset_ptr) override;
3232 };
3333
34 }
34 } // namespace llvm
3535
3636 #endif
3737
278278 const DWARFDebugInfoEntryMinimal *getSubprogramForAddress(uint64_t Address);
279279 };
280280
281 }
281 } // namespace llvm
282282
283283 #endif
5353
5454 std::unique_ptr Enumerator;
5555 };
56 }
56 } // namespace llvm
5757
5858 #endif
3131 virtual void reset() = 0;
3232 virtual IPDBDataStream *clone() const = 0;
3333 };
34 }
34 } // namespace llvm
3535
3636 #endif
2727 virtual void reset() = 0;
2828 virtual MyType *clone() const = 0;
2929 };
30 }
30 } // namespace llvm
3131
3232 #endif
3030 virtual uint32_t getCompilandId() const = 0;
3131 virtual bool isStatement() const = 0;
3232 };
33 }
33 } // namespace llvm
3434
3535 #endif
5555
5656 virtual std::unique_ptr getDebugStreams() const = 0;
5757 };
58 }
58 } // namespace llvm
5959
6060 #endif
3131 virtual PDB_Checksum getChecksumType() const = 0;
3232 virtual std::unique_ptr getCompilands() const = 0;
3333 };
34 }
34 } // namespace llvm
3535
3636 #endif
5454 std::string getFunctionName(uint64_t Address, DINameKind NameKind) const;
5555 std::unique_ptr Session;
5656 };
57 }
57 } // namespace llvm
5858
5959 #endif
3232 raw_ostream &operator<<(raw_ostream &OS, const Variant &Value);
3333 raw_ostream &operator<<(raw_ostream &OS, const VersionInfo &Version);
3434 raw_ostream &operator<<(raw_ostream &OS, const TagStats &Stats);
35 }
35 } // namespace llvm
3636
3737 #endif
5555 private:
5656 bool RequireImpl;
5757 };
58 }
58 } // namespace llvm
5959
6060 #endif
3333 // FORWARD_SYMBOL_METHOD(getValue)
3434 FORWARD_SYMBOL_METHOD(getVirtualAddress)
3535 };
36 }
36 } // namespace llvm
3737
3838 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLANNOTATION_H
3535 FORWARD_SYMBOL_METHOD(getSymIndexId)
3636 FORWARD_SYMBOL_METHOD(getVirtualAddress)
3737 };
38 }
38 } // namespace llvm
3939
4040 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLBLOCK_H
3232 FORWARD_SYMBOL_METHOD(getSourceFileName)
3333 FORWARD_SYMBOL_METHOD(getSymIndexId)
3434 };
35 }
35 } // namespace llvm
3636
3737 #endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILAND_H
628628 // Create wrappers for C Binding types (see CBindingWrapping.h).
629629 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionEngine, LLVMExecutionEngineRef)
630630
631 } // End llvm namespace
631 } // namespace llvm
632632
633633 #endif
4848 inline GenericValue PTOGV(void *P) { return GenericValue(P); }
4949 inline void* GVTOP(const GenericValue &GV) { return GV.PointerVal; }
5050
51 } // End llvm namespace.
51 } // namespace llvm
5252 #endif
3232 LLVMLinkInMCJIT();
3333 }
3434 } ForceMCJITLinking;
35 }
35 } // namespace
3636
3737 #endif
3434 virtual std::unique_ptr getObject(const Module* M) = 0;
3535 };
3636
37 }
37 } // namespace llvm
3838
3939 #endif
9999 MemoryGroup RODataMem;
100100 };
101101
102 }
102 } // namespace llvm
103103
104104 #endif // LLVM_EXECUTION_ENGINE_SECTION_MEMORY_MANAGER_H
105105
130130 }
131131 };
132132
133 } // End llvm namespace
133 } // namespace llvm
134134
135135 #endif
5757 virtual void printInfoComment(const Value &, formatted_raw_ostream &) {}
5858 };
5959
60 } // End llvm namespace
60 } // namespace llvm
6161
6262 #endif
574574
575575 } // end AttributeFuncs namespace
576576
577 } // end llvm namespace
577 } // namespace llvm
578578
579579 #endif
6565
6666 /// Upgrade a metadata string constant in place.
6767 void UpgradeMDStringConstant(std::string &String);
68 } // End llvm namespace
68 } // namespace llvm
6969
7070 #endif
345345 // Create wrappers for C Binding types (see CBindingWrapping.h).
346346 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef)
347347
348 } // End llvm namespace
348 } // namespace llvm
349349
350350 #endif
395395 }
396396 };
397397
398 } // End llvm namespace
398 } // namespace llvm
399399
400400 #endif
396396 ImmutableCallSite(CallSite CS) : CallSiteBase(CS.getInstruction()) {}
397397 };
398398
399 } // End llvm namespace
399 } // namespace llvm
400400
401401 #endif
145145 /// in SSE registers.
146146 X86_VectorCall = 80
147147 };
148 } // End CallingConv namespace
148 } // namespace CallingConv
149149
150 } // End llvm namespace
150 } // namespace llvm
151151
152152 #endif
6060 return OS;
6161 }
6262
63 } // end llvm namespace
63 } // namespace llvm
6464
6565 #endif
186186 }
187187 };
188188
189 } // End llvm namespace
189 } // namespace llvm
190190
191191 #endif
239239 }
240240 };
241241
242 }
242 } // namespace llvm
243243
244244 #endif
272272 return OS;
273273 }
274274
275 } // End llvm namespace
275 } // namespace llvm
276276
277277 #endif
12311231 }
12321232 };
12331233
1234 } // End llvm namespace
1234 } // namespace llvm
12351235
12361236 #endif
541541 }
542542 }
543543
544 } // End llvm namespace
544 } // namespace llvm
545545
546546 #endif
476476 }
477477 };
478478
479 } // End llvm namespace
479 } // namespace llvm
480480
481481 #endif
229229 void print(raw_ostream &OS, const Module *M = nullptr) const override;
230230 };
231231
232 } // End llvm namespace
232 } // namespace llvm
233233
234234 #endif
617617
618618 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Function, Value)
619619
620 } // End llvm namespace
620 } // namespace llvm
621621
622622 #endif
5858 virtual std::vector getIdentifiedStructTypes() const = 0;
5959 };
6060
61 } // End llvm namespace
61 } // namespace llvm
6262
6363 #endif
117117
118118 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalAlias, Constant)
119119
120 } // End llvm namespace
120 } // namespace llvm
121121
122122 #endif
7070 }
7171 };
7272
73 } // End llvm namespace
73 } // namespace llvm
7474
7575 #endif
366366 }
367367 };
368368
369 } // End llvm namespace
369 } // namespace llvm
370370
371371 #endif
182182
183183 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalVariable, Value)
184184
185 } // End llvm namespace
185 } // namespace llvm
186186
187187 #endif
16781678 // Create wrappers for C Binding types (see CBindingWrapping.h).
16791679 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)
16801680
1681 }
1681 } // namespace llvm
16821682
16831683 #endif
8282 static StringRef name() { return "PrintFunctionPass"; }
8383 };
8484
85 } // End llvm namespace
85 } // namespace llvm
8686
8787 #endif
357357
358358 };
359359
360 } // End llvm namespace
360 } // namespace llvm
361361
362362 #endif
152152 return iterator_range(inst_begin(F), inst_end(F));
153153 }
154154
155 } // End llvm namespace
155 } // namespace llvm
156156
157157 #endif
283283
284284 #undef DELEGATE
285285
286 } // End llvm namespace
286 } // namespace llvm
287287
288288 #endif
893893
894894 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value)
895895
896 } // End llvm namespace
896 } // namespace llvm
897897
898898 #endif
535535 enum { NumLowBitsAvailable = 2 };
536536 };
537537
538 } // End llvm namespace
538 } // namespace llvm
539539
540540 #endif
39823982 }
39833983 };
39843984
3985 } // End llvm namespace
3985 } // namespace llvm
39863986
39873987 #endif
371371 return cast(const_cast(getArgOperand(3)));
372372 }
373373 };
374 }
374 } // namespace llvm
375375
376376 #endif
125125 /// of IITDescriptors.
126126 void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl &T);
127127
128 } // End Intrinsic namespace
128 } // namespace Intrinsic
129129
130 } // End llvm namespace
130 } // namespace llvm
131131
132132 #endif
208208 return reinterpret_cast(const_cast(Tys));
209209 }
210210
211 }
211 } // namespace llvm
212212
213213 #endif
9292 Module *M;
9393 };
9494
95 } // End legacy namespace
95 } // namespace legacy
9696
9797 // Create wrappers for C Binding types (see CBindingWrapping.h).
9898 DEFINE_STDCXX_CONVERSION_FUNCTIONS(legacy::PassManagerBase, LLVMPassManagerRef)
9999
100 } // End llvm namespace
100 } // namespace llvm
101101
102102 #endif
473473
474474 Timer *getPassTimer(Pass *);
475475
476 }
476 } // namespace llvm
477477
478478 #endif
133133 }
134134 };
135135
136 } // End llvm namespace
136 } // namespace llvm
137137
138138 #endif
6363 ManglerPrefixTy PrefixTy = Mangler::Default) const;
6464 };
6565
66 } // End llvm namespace
66 } // namespace llvm
6767
6868 #endif
12021202 }
12031203 };
12041204
1205 } // end llvm namespace
1205 } // namespace llvm
12061206
12071207 #endif
693693 return reinterpret_cast(MP);
694694 }
695695
696 } // End llvm namespace
696 } // namespace llvm
697697
698698 #endif
293293 }
294294 };
295295
296 }
296 } // namespace llvm
297297
298298 #endif
154154 }
155155
156156
157 } // End llvm namespace
157 } // namespace llvm
158158
159159 #endif
490490 }
491491 };
492492
493 } // End llvm namespace
493 } // namespace llvm
494494
495495 #endif
889889 static StringRef name() { return "InvalidateAllAnalysesPass"; }
890890 };
891891
892 }
892 } // namespace llvm
893893
894894 #endif
344344 };
345345
346346 } // End namespace detail
347 }
347 } // namespace llvm
348348
349349 #endif
348348 }
349349 return Result;
350350 }
351 }
351 } // namespace llvm
352352
353353 #endif
7272 static ValueSymbolTable *toPtr(ValueSymbolTable &R) { return &R; }
7373 };
7474
75 } // End llvm namespace
75 } // namespace llvm
7676
7777 #endif
483483 return reinterpret_cast(const_cast(Tys));
484484 }
485485
486 } // End llvm namespace
486 } // namespace llvm
487487
488488 #endif
7373 void incorporateMDNode(const MDNode *V);
7474 };
7575
76 } // end llvm namespace
76 } // namespace llvm
7777
7878 #endif
167167 // Create wrappers for C Binding types (see CBindingWrapping.h).
168168 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use, LLVMUseRef)
169169
170 }
170 } // namespace llvm
171171
172172 #endif
258258 }
259259 };
260260
261 } // End llvm namespace
261 } // namespace llvm
262262
263263 #endif
715715 return reinterpret_cast(const_cast(Vals));
716716 }
717717
718 } // End llvm namespace
718 } // namespace llvm
719719
720720 #endif
379379 virtual void allUsesReplacedWith(Value *) {}
380380 };
381381
382 } // End llvm namespace
383
384 #endif
382 } // namespace llvm
383
384 #endif
127127 /// @}
128128 };
129129
130 } // End llvm namespace
130 } // namespace llvm
131131
132132 #endif
7171 static StringRef name() { return "VerifierPass"; }
7272 };
7373
74 } // End llvm namespace
74 } // namespace llvm
7575
7676 #endif
4242 /// for it.
4343 std::unique_ptr parseIRFile(StringRef Filename, SMDiagnostic &Err,
4444 LLVMContext &Context);
45 }
45 } // namespace llvm
4646
4747 #endif
301301 void initializeDwarfEHPreparePass(PassRegistry&);
302302 void initializeFloat2IntPass(PassRegistry&);
303303 void initializeLoopDistributePass(PassRegistry&);
304 }
304 } // namespace llvm
305305
306306 #endif
176176 bool ShouldInternalize = true;
177177 bool ShouldEmbedUselists = false;
178178 };
179 }
179 } // namespace llvm
180180 #endif
223223 static LTOModule *makeLTOModule(MemoryBufferRef Buffer, TargetOptions options,
224224 std::string &errMsg, LLVMContext *Context);
225225 };
226 }
226 } // namespace llvm
227227 #endif
147147 std::unique_ptr Completer;
148148 };
149149
150 }
150 } // namespace llvm
151151
152152 #endif
8989 DiagnosticHandlerFunction DiagnosticHandler;
9090 };
9191
92 } // End llvm namespace
92 } // namespace llvm
9393
9494 #endif
137137 }
138138 };
139139
140 } // End llvm namespace
140 } // namespace llvm
141141
142142 #endif
3838 X86, /// Windows x86, uses no CFI, just EH tables
3939 MIPS = Alpha,
4040 };
41 }
41 } // namespace WinEH
4242
4343 enum class ExceptionHandling {
4444 None, /// No exception support
554554
555555 bool shouldUseLogicalShr() const { return UseLogicalShr; }
556556 };
557 }
557 } // namespace llvm
558558
559559 #endif
2929 protected:
3030 explicit MCAsmInfoGNUCOFF();
3131 };
32 }
32 } // namespace llvm
3333
3434
3535 #endif // LLVM_MC_MCASMINFOCOFF_H
4040 const MCSubtargetInfo &STI) const = 0;
4141 };
4242
43 } // End llvm namespace
43 } // namespace llvm
4444
4545 #endif
131131 MCObjectWriter *createELFObjectWriter(MCELFObjectTargetWriter *MOTW,
132132 raw_pwrite_stream &OS,
133133 bool IsLittleEndian);
134 } // End llvm namespace
134 } // namespace llvm
135135
136136 #endif
5252 uint64_t Address) override;
5353 };
5454
55 }
55 } // namespace llvm
5656
5757 #endif
2525 OPC_Fail // OPC_Fail()
2626 };
2727
28 } // namespace MCDecode
28 } // namespace MCD
2929 } // namespace llvm
3030
3131 #endif
107107 SMLoc getLoc() const { return Loc; }
108108 };
109109
110 } // End llvm namespace
110 } // namespace llvm
111111
112112 #endif
3737 unsigned Flags;
3838 };
3939
40 } // End llvm namespace
40 } // namespace llvm
4141
4242 #endif
6565 uint64_t &Target) const;
6666 };
6767
68 } // End llvm namespace
68 } // namespace llvm
6969
7070 #endif
4848 OPERAND_PCREL = 4,
4949 OPERAND_FIRST_TARGET = 5
5050 };
51 }
51 } // namespace MCOI
5252
5353 /// \brief This holds information about one operand of a machine instruction,
5454 /// indicating the register class for register operands, etc.
127127 InsertSubreg,
128128 Convergent
129129 };
130 }
130 } // namespace MCID
131131
132132 /// \brief Describe properties that are true of each instruction in the target
133133 /// description file. This captures information about side effects, register
5353 }
5454 };
5555
56 } // End llvm namespace
56 } // namespace llvm
5757
5858 #endif
233233 }
234234 };
235235
236 } // End llvm namespace
236 } // namespace llvm
237237
238238 #endif
263263 raw_pwrite_stream &OS,
264264 bool IsLittleEndian);
265265
266 } // End llvm namespace
266 } // namespace llvm
267267
268268 #endif
187187 /// @}
188188 };
189189
190 } // End llvm namespace
190 } // namespace llvm
191191
192192 #endif
189189 void setAllowAtInIdentifier(bool v) { AllowAtInIdentifier = v; }
190190 };
191191
192 } // End llvm namespace
192 } // namespace llvm
193193
194194 #endif
202202 MCAsmParser *createMCAsmParser(SourceMgr &, MCContext &, MCStreamer &,
203203 const MCAsmInfo &);
204204
205 } // End llvm namespace
205 } // namespace llvm
206206
207207 #endif
8383 /// @}
8484 };
8585
86 } // End llvm namespace
86 } // namespace llvm
8787
8888 #endif
685685 }
686686 };
687687
688 } // End llvm namespace
688 } // namespace llvm
689689
690690 #endif
4949 unsigned VariantKind);
5050 };
5151
52 }
52 } // namespace llvm
5353
5454 #endif
244244 }
245245 };
246246
247 } // End llvm namespace
247 } // namespace llvm
248248
249249 #endif
159159 }
160160 };
161161
162 } // End llvm namespace
162 } // namespace llvm
163163
164164 #endif
5858
5959 static bool classof(const MCSymbol *S) { return S->isCOFF(); }
6060 };
61 }
61 } // namespace llvm
6262
6363 #endif
4848 private:
4949 void setIsBindingSet() const;
5050 };
51 }
51 } // namespace llvm
5252
5353 #endif
117117
118118 static bool classof(const MCSymbol *S) { return S->isMachO(); }
119119 };
120 }
120 } // namespace llvm
121121
122122 #endif
7979 uint64_t Address) = 0;
8080 };
8181
82 }
82 } // namespace llvm
8383
8484 #endif
200200 virtual void onLabelParsed(MCSymbol *Symbol) { };
201201 };
202202
203 } // End llvm namespace
203 } // namespace llvm
204204
205205 #endif
5656 void Emit(MCStreamer &Streamer) const override;
5757 void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI) const override;
5858 };
59 }
59 } // namespace Win64EH
6060 } // end namespace llvm
6161
6262 #endif
4141 /// \returns The constructed object writer.
4242 MCObjectWriter *createWinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW,
4343 raw_pwrite_stream &OS);
44 } // End llvm namespace
44 } // namespace llvm
4545
4646 #endif
7474 private:
7575 LLVM_ATTRIBUTE_NORETURN void FatalError(const Twine &Msg) const;
7676 };
77 }
77 } // namespace llvm
7878
7979 #endif
8080
7777 virtual void Emit(MCStreamer &Streamer) const = 0;
7878 virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI) const = 0;
7979 };
80 }
81 }
80 } // namespace WinEH
81 } // namespace llvm
8282
8383 #endif
7777 return !(LHS == RHS);
7878 }
7979
80 } // End llvm namespace
80 } // namespace llvm
8181
8282 #endif
6161 }
6262 };
6363
64 } // end llvm namespace
64 } // namespace llvm
6565
6666 #endif
8888 static StringRef input(StringRef, void *, BinaryRef &);
8989 static bool mustQuote(StringRef S) { return needsQuotes(S); }
9090 };
91 }
92 }
91 } // namespace yaml
92 } // namespace llvm
9393 #endif
216216 unsigned IsThin : 1;
217217 };
218218
219 }
220 }
219 } // namespace object
220 } // namespace llvm
221221
222222 #endif
4545 writeArchive(StringRef ArcName, std::vector &NewMembers,
4646 bool WriteSymtab);
4747
48 }
48 } // namespace llvm
4949
5050 #endif
177177 }
178178
179179 ErrorOr> createBinary(StringRef Path);
180 }
181 }
180 } // namespace object
181 } // namespace llvm
182182
183183 #endif
3636 uint16_t Ret = static_cast(a) | static_cast(b);
3737 return static_cast(Ret);
3838 }
39 }
39 } // namespace COFF
4040
4141 // The structure of the yaml files is not an exact 1:1 match to COFF. In order
4242 // to use yaml::IO, we use these structures which are closer to the source.
8686 std::vector Symbols;
8787 Object();
8888 };
89 }
90 }
89 } // namespace COFFYAML
90 } // namespace llvm
9191
9292 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Section)
9393 LLVM_YAML_IS_SEQUENCE_VECTOR(COFFYAML::Symbol)
897897 return cast(Obj)
898898 ->getSymbolVersion(Sym, Version, IsDefault);
899899 }
900 }
901 }
900 } // namespace object
901 } // namespace llvm
902902
903903 #endif
6767 static ErrorOr> create(MemoryBufferRef Object,
6868 LLVMContext &Context);
6969 };
70 }
71 }
70 } // namespace object
71 } // namespace llvm
7272
7373 #endif
502502 return OwningObject;
503503 }
504504
505 }
506 }
505 } // namespace object
506 } // namespace llvm
507507
508508 #endif
509509
111111 getObjectForArch(Triple::ArchType Arch) const;
112112 };
113113
114 }
115 }
114 } // namespace object
115 } // namespace llvm
116116
117117 #endif
445445 }
446446 };
447447
448 }
449 }
448 } // namespace object
449 } // namespace llvm
450450 #endif
194194 return OwningObject;
195195 }
196196
197 }
198 }
197 } // namespace object
198 } // namespace llvm
199199
200200 #endif
3434 bool operator==(OptSpecifier Opt) const { return ID == Opt.getID(); }
3535 bool operator!=(OptSpecifier Opt) const { return !(*this == Opt); }
3636 };
37 }
38 }
37 } // namespace opt
38 } // namespace llvm
3939
4040 #endif
368368 /// @brief This is the storage for the -time-passes option.
369369 extern bool TimePassesIsEnabled;
370370
371 } // End llvm namespace
371 } // namespace llvm
372372
373373 // Include support files that contain important APIs commonly used by Passes,
374374 // but that we want to separate out to make it easier to read the header files.
247247 return *(AnalysisType*)ResultPass->getAdjustedAnalysisPointer(PI);
248248 }
249249
250 } // End llvm namespace
250 } // namespace llvm
251251
252252 #endif
141141 PassInfo(const PassInfo &) = delete;
142142 };
143143
144 }
144 } // namespace llvm
145145
146146 #endif
9494 // Create wrappers for C Binding types (see CBindingWrapping.h).
9595 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassRegistry, LLVMPassRegistryRef)
9696
97 }
97 } // namespace llvm
9898
9999 #endif
244244 };
245245
246246
247 } // End llvm namespace
247 } // namespace llvm
248248
249249 #endif
9999 bool VerifyEachPass, bool DebugLogging);
100100 };
101101
102 }
102 } // namespace llvm
103103
104104 #endif
126126
127127 NUM_PERSONALITY_INDEX
128128 };
129 }
130 }
131 }
129 } // namespace EHABI
130 } // namespace ARM
131 } // namespace llvm
132132
133133 #endif
374374 inline size_t HeaderWords(const ExceptionDataRecord &XR) {
375375 return (XR.Data[0] & 0xff800000) ? 1 : 2;
376376 }
377 }
378 }
379 }
377 } // namespace WinEH
378 } // namespace ARM
379 } // namespace llvm
380380
381381 #endif
137137 }
138138 };
139139
140 } // end llvm namespace
140 } // namespace llvm
141141
142142 #endif
3232 cas_flag AtomicAdd(volatile cas_flag* ptr, cas_flag val);
3333 cas_flag AtomicMul(volatile cas_flag* ptr, cas_flag val);
3434 cas_flag AtomicDiv(volatile cas_flag* ptr, cas_flag val);
35 }
36 }
35 } // namespace sys
36 } // namespace llvm
3737
3838 #endif
6868 }
6969 };
7070
71 }
71 } // namespace llvm
7272
7373 #endif
8383 return Prob.print(OS);
8484 }
8585
86 }
86 } // namespace llvm
8787
8888 #endif
2929 InitializeCOMRAII(const InitializeCOMRAII &) = delete;
3030 void operator=(const InitializeCOMRAII &) = delete;
3131 };
32 }
33 }
32 } // namespace sys
33 } // namespace llvm
3434
3535 #endif
320320 return (Val && isa(Val)) ? cast(Val) : nullptr;
321321 }
322322
323 } // End llvm namespace
323 } // namespace llvm
324324
325325 #endif
8989 }
9090 llvm_unreachable("Bad CodeModel!");
9191 }
92 } // end llvm namespace
92 } // namespace llvm
9393
9494 #endif
198198 cleanup = 0;
199199 }
200200 };
201 }
201 } // namespace llvm
202202
203203 #endif
160160 DOTGraphTraits (bool simple=false) : DefaultDOTGraphTraits (simple) {}
161161 };
162162
163 } // End llvm namespace
163 } // namespace llvm
164164
165165 #endif
3232
3333 std::unique_ptr getDataFileStreamer(const std::string &Filename,
3434 std::string *Err);
35 }
35 } // namespace llvm
3636
3737 #endif // LLVM_SUPPORT_DATASTREAM_H_
9090 //
9191 #define DEBUG(X) DEBUG_WITH_TYPE(DEBUG_TYPE, X)
9292
93 } // End llvm namespace
93 } // namespace llvm
9494
9595 #endif
9898 static void AddSymbol(StringRef symbolName, void *symbolValue);
9999 };
100100
101 } // End sys namespace
102 } // End llvm namespace
101 } // namespace sys
102 } // namespace llvm
103103
104104 #endif
7777 inline std::error_code make_error_code(errc E) {
7878 return std::error_code(static_cast(E), std::generic_category());
7979 }
80 }
80 } // namespace llvm
8181
8282 namespace std {
8383 template <> struct is_error_code_enum : std::true_type {};
8383 LLVM_ATTRIBUTE_NORETURN void
8484 llvm_unreachable_internal(const char *msg=nullptr, const char *file=nullptr,
8585 unsigned line=0);
86 }
86 } // namespace llvm
8787
8888 /// Marks that the current location is not supposed to be reachable.
8989 /// In !NDEBUG builds, prints the message and location info to stderr.
723723 intptr_t IterationHandle;
724724 directory_entry CurrentEntry;
725725 };
726 }
726 } // namespace detail
727727
728728 /// directory_iterator - Iterates through the entries in path. There is no
729729 /// operator++ because we need an error_code. If it's really needed we can make
785785 uint16_t Level;
786786 bool HasNoPushRequest;
787787 };
788 }
788 } // namespace detail
789789
790790 /// recursive_directory_iterator - Same as directory_iterator except for it
791791 /// recurses down into child directories.
7272 /// will not be removed when the object is destroyed.
7373 void releaseFile() { DeleteIt = false; }
7474 };
75 } // End llvm namespace
75 } // namespace llvm
7676
7777 #endif
155155 /// debug output. Use it like: fdbgs() << "foo" << "bar";
156156 formatted_raw_ostream &fdbgs();
157157
158 } // end llvm namespace
158 } // namespace llvm
159159
160160
161161 #endif
434434 FileCoverageList FileCoverages;
435435 FuncCoverageMap FuncCoverages;
436436 };
437 }
437 } // namespace llvm
438438
439439 #endif
771771 getNode(const_cast(B)));
772772 }
773773
774 }
774 } // namespace llvm
775775
776776 #endif
287287 DT.updateDFSNumbers();
288288 }
289289
290 }
290 } // namespace llvm
291291
292292 #endif
355355 DisplayGraph(Filename, true, Program);
356356 }
357357
358 } // End llvm namespace
358 } // namespace llvm
359359
360360 #endif
6767 ///
6868 /// \return - True on success.
6969 bool getHostCPUFeatures(StringMap &Features);
70 }
71 }
70 } // namespace sys
71 } // namespace llvm
7272
7373 #endif
8282 /// \brief Advance the iterator to the next line.
8383 void advance();
8484 };
85 }
85 } // namespace llvm
8686
8787 #endif
6464 const uint8_t *body(ArrayRef Data);
6565 };
6666
67 }
67 } // namespace llvm
6868
6969 #endif
105105 ~llvm_shutdown_obj() { llvm_shutdown(); }
106106 };
107107
108 }
108 } // namespace llvm
109109
110110 #endif
641641 }
642642
643643 extern const float huge_valf;
644 } // End llvm namespace
645
646 #endif
644 } // namespace llvm
645
646 #endif
154154 /// as writable.
155155 static bool setRangeWritable(const void *Addr, size_t Size);
156156 };
157 }
158 }
157 } // namespace sys
158 } // namespace llvm
159159
160160 #endif
6262 virtual bool isValidAddress(uint64_t address) const = 0;
6363 };
6464
65 }
65 } // namespace llvm
6666
6767 #endif
9595 Val_GNU_MIPS_ABI_MSA_ANY = 0, // not tagged
9696 Val_GNU_MIPS_ABI_MSA_128 = 1 // 128-bit MSA
9797 };
98 }
99 }
98 } // namespace Mips
99 } // namespace llvm
100100
101101 #endif