1 /* { dg-do compile } */
2 /* { dg-require-visibility "" } */
3 
4 typedef unsigned int size_t;
5 namespace std __attribute__ ((__visibility__ ("default")))
6 {
7   template < typename _Iterator > struct iterator_traits
8   {
9   };
10   template < typename _Tp > struct iterator_traits <_Tp * >
11   {
12     typedef _Tp & reference;
13   };
14 }
15 
16 namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
17 {
18   using std::iterator_traits;
19   template < typename _Iterator, typename _Container > class __normal_iterator
20   {
21   public:typedef _Iterator iterator_type;
22     typedef typename iterator_traits < _Iterator >::reference reference;
23     reference operator* () const
24     {
25     }
26     __normal_iterator operator++ (int)
27     {
28     }
29   };
30   template < typename _IteratorL, typename _IteratorR,
31     typename _Container > inline bool operator!= (const __normal_iterator <
32 						  _IteratorL,
33 						  _Container > &__lhs,
34 						  const __normal_iterator <
35 						  _IteratorR,
36 						  _Container > &__rhs)
37   {
38   }
39 }
40 
41 extern "C"
42 {
43   extern "C"
44   {
45     __extension__ typedef __SIZE_TYPE__ __intptr_t;
46   }
47 }
48 namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
49 {
50   template < typename _Tp > class new_allocator
51   {
52   public:typedef size_t size_type;
53     typedef _Tp *pointer;
54     template < typename _Tp1 > struct rebind
55     {
56       typedef new_allocator < _Tp1 > other;
57     };
58   };
59 }
60 
61 namespace std __attribute__ ((__visibility__ ("default")))
62 {
63 template < typename _Tp > class allocator:public __gnu_cxx::new_allocator <
64     _Tp >
65   {
66   };
67 }
68 
69 extern "C"
70 {
71   typedef __intptr_t intptr_t;
72 }
73 namespace llvm
74 {
75   template < typename NodeTy > class ilist_half_node
76   {
77   };
78 template < typename NodeTy > class ilist_node:private ilist_half_node <
79     NodeTy >
80   {
81   };
82   class MachineBasicBlock;
83   class MachineOperand
84   {
85   public:enum MachineOperandType
86     {
87     }
88     Contents;
89     unsigned getReg () const
90     {
91     }
92   };
93   class TargetRegisterInfo;
94 }
95 
96 namespace std __attribute__ ((__visibility__ ("default")))
97 {
98   template < typename _Tp, typename _Alloc > struct _Vector_base
99   {
100     typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type;
101   };
102 template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class vector:protected _Vector_base < _Tp,
103     _Alloc
104     >
105   {
106     typedef _Vector_base < _Tp, _Alloc > _Base;
107     typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
108   public:typedef _Tp value_type;
109     typedef typename _Tp_alloc_type::pointer pointer;
110     typedef __gnu_cxx::__normal_iterator < pointer, vector > iterator;
111     iterator begin ()
112     {
113     }
114     iterator end ()
115     {
116     }
117   };
118 }
119 
120 namespace llvm
121 {
122   class MachineFunction;
123   class MachineInstr:public ilist_node < MachineInstr >
124   {
125   public:const MachineBasicBlock *getParent () const
126     {
127     }
128     const MachineOperand & getOperand (unsigned i) const
129     {
130     }
131     bool registerDefIsDead (unsigned Reg, const TargetRegisterInfo * TRI =
132 			    __null) const
133     {
134     }
135   };
136   class AnalysisResolver;
137   class Pass
138   {
139     AnalysisResolver *Resolver;
140     intptr_t PassID;
141   public:  explicit Pass (intptr_t pid):Resolver (0), PassID (pid)
142     {
143     }
144     explicit Pass (const void *pid):Resolver (0), PassID ((intptr_t) pid)
145     {
146     }
147     template < typename AnalysisType > AnalysisType & getAnalysis () const;
148   };
149   class FunctionPass:public Pass
150   {
151   public:explicit FunctionPass (intptr_t pid):Pass (pid)
152     {
153     }
154     explicit FunctionPass (const void *pid):Pass (pid)
155     {
156     }
157   };
158   class PassInfo
159   {
160   public:typedef Pass *(*NormalCtor_t) ();
161   private:const char *const PassName;
162     const char *const PassArgument;
163     const intptr_t PassID;
164     const bool IsCFGOnlyPass;
165     const bool IsAnalysis;
166     const bool IsAnalysisGroup;
167     NormalCtor_t NormalCtor;
168   public:   PassInfo (const char *name, const char *arg, intptr_t pi, NormalCtor_t normal = 0, bool isCFGOnly = false, bool is_analysis = false):PassName (name), PassArgument (arg), PassID (pi),
169       IsCFGOnlyPass (isCFGOnly), IsAnalysis (is_analysis),
170       IsAnalysisGroup (false), NormalCtor (normal)
171     {
172     }
173   };
174   template < typename PassName > Pass * callDefaultCtor ()
175   {
176     return new PassName ();
177   }
178   template < typename passName > struct RegisterPass:public PassInfo
179   {
180   RegisterPass (const char *PassArg, const char *Name, bool CFGOnly = false, bool is_analysis = false):PassInfo (Name, PassArg, intptr_t (&passName::ID),
181 	      PassInfo::NormalCtor_t (callDefaultCtor < passName >), CFGOnly,
182 	      is_analysis)
183     {
184     }
185   };
186   template < typename T > class SmallVectorImpl
187   {
188   };
189   template < typename T,
190     unsigned N > class SmallVector:public SmallVectorImpl < T >
191   {
192   };
193   class MachineFunctionPass:public FunctionPass
194   {
195   protected:explicit MachineFunctionPass (intptr_t ID):FunctionPass (ID)
196     {
197     }
198     explicit MachineFunctionPass (void *ID):FunctionPass (ID)
199     {
200     }
201     virtual bool runOnMachineFunction (MachineFunction & MF) = 0;
202   };
203   class LiveIndex
204   {
205   private:unsigned index;
206   };
207   class VNInfo
208   {
209   };
210   struct LiveRange
211   {
212     LiveIndex start;
213     LiveIndex end;
214     VNInfo *valno;
215   };
216   class LiveInterval
217   {
218   public:typedef SmallVector < LiveRange, 4 > Ranges;
219     bool containsOneValue () const
220     {
221     }
222     LiveRange *getLiveRangeContaining (LiveIndex Idx)
223     {
224     }
225     void removeRange (LiveIndex Start, LiveIndex End, bool RemoveDeadValNo =
226 		      false);
227     void removeRange (LiveRange LR, bool RemoveDeadValNo = false)
228     {
229       removeRange (LR.start, LR.end, RemoveDeadValNo);
230     }
231   };
232   class LiveIntervals:public MachineFunctionPass
233   {
234   public:static char ID;
235     LiveIndex getDefIndex (LiveIndex index)
236     {
237     }
238     LiveInterval & getInterval (unsigned reg)
239     {
240     }
241     LiveIndex getInstructionIndex (const MachineInstr * instr) const
242     {
243     }
244   };
245 }
246 
247 using namespace llvm;
248 namespace
249 {
250 struct __attribute__ ((visibility ("hidden"))) StrongPHIElimination:public
251     MachineFunctionPass
252   {
253     static char ID;
254   StrongPHIElimination ():MachineFunctionPass (&ID)
255     {
256     }
257     bool runOnMachineFunction (MachineFunction & Fn);
258   };
259 }
260 
261 static RegisterPass < StrongPHIElimination > X ("strong-phi-node-elimination",
262 						"Eliminate PHI nodes for register allocation, intelligently");
263 bool
264 StrongPHIElimination::runOnMachineFunction (MachineFunction & Fn)
265 {
266   LiveIntervals & LI = getAnalysis < LiveIntervals > ();
267   std::vector < MachineInstr * >phis;
268   for (std::vector < MachineInstr * >::iterator I = phis.begin (), E =
269        phis.end (); I != E;)
270     {
271       MachineInstr *PInstr = *(I++);
272       unsigned DestReg = PInstr->getOperand (0).getReg ();
273       LiveInterval & PI = LI.getInterval (DestReg);
274       if (PInstr->registerDefIsDead (DestReg))
275 	{
276 	  if (PI.containsOneValue ())
277 	    {
278 	      LiveIndex idx =
279 		LI.getDefIndex (LI.getInstructionIndex (PInstr));
280 	      PI.removeRange (*PI.getLiveRangeContaining (idx), true);
281 	    }
282 	}
283     }
284 }
285