Subversion Repositories openrisc

/* { dg-do compile } */

/* { dg-require-visibility "" } */

typedef unsigned int size_t;

namespace std __attribute__ ((__visibility__ ("default")))

{

  template < typename _Iterator > struct iterator_traits

  {

  };

  template < typename _Tp > struct iterator_traits <_Tp * >

  {

    typedef _Tp & reference;

  };

}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))

{

  using std::iterator_traits;

  template < typename _Iterator, typename _Container > class __normal_iterator

  {

  public:typedef _Iterator iterator_type;

    typedef typename iterator_traits < _Iterator >::reference reference;

    reference operator* () const

    {

    }

    __normal_iterator operator++ (int)

    {

    }

  };

  template < typename _IteratorL, typename _IteratorR,

    typename _Container > inline bool operator!= (const __normal_iterator <

                                                  _IteratorL,

                                                  _Container > &__lhs,

                                                  const __normal_iterator <

                                                  _IteratorR,

                                                  _Container > &__rhs)

  {

  }

}

extern "C"

{

  extern "C"

  {

    __extension__ typedef __SIZE_TYPE__ __intptr_t;

  }

}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))

{

  template < typename _Tp > class new_allocator

  {

  public:typedef size_t size_type;

    typedef _Tp *pointer;

    template < typename _Tp1 > struct rebind

    {

      typedef new_allocator < _Tp1 > other;

    };

  };

}

namespace std __attribute__ ((__visibility__ ("default")))

{

template < typename _Tp > class allocator:public __gnu_cxx::new_allocator <

    _Tp >

  {

  };

}

extern "C"

{

  typedef __intptr_t intptr_t;

}

namespace llvm

{

  template < typename NodeTy > class ilist_half_node

  {

  };

template < typename NodeTy > class ilist_node:private ilist_half_node <

    NodeTy >

  {

  };

  class MachineBasicBlock;

  class MachineOperand

  {

  public:enum MachineOperandType

    {

    }

    Contents;

    unsigned getReg () const

    {

    }

  };

  class TargetRegisterInfo;

}

namespace std __attribute__ ((__visibility__ ("default")))

{

  template < typename _Tp, typename _Alloc > struct _Vector_base

  {

    typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type;

  };

template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class vector:protected _Vector_base < _Tp,

    _Alloc

    >

  {

    typedef _Vector_base < _Tp, _Alloc > _Base;

    typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;

  public:typedef _Tp value_type;

    typedef typename _Tp_alloc_type::pointer pointer;

    typedef __gnu_cxx::__normal_iterator < pointer, vector > iterator;

    iterator begin ()

    {

    }

    iterator end ()

    {

    }

  };

}

namespace llvm

{

  class MachineFunction;

  class MachineInstr:public ilist_node < MachineInstr >

  {

  public:const MachineBasicBlock *getParent () const

    {

    }

    const MachineOperand & getOperand (unsigned i) const

    {

    }

    bool registerDefIsDead (unsigned Reg, const TargetRegisterInfo * TRI =

                            __null) const

    {

    }

  };

  class AnalysisResolver;

  class Pass

  {

    AnalysisResolver *Resolver;

    intptr_t PassID;

  public:  explicit Pass (intptr_t pid):Resolver (0), PassID (pid)

    {

    }

    explicit Pass (const void *pid):Resolver (0), PassID ((intptr_t) pid)

    {

    }

    template < typename AnalysisType > AnalysisType & getAnalysis () const;

  };

  class FunctionPass:public Pass

  {

  public:explicit FunctionPass (intptr_t pid):Pass (pid)

    {

    }

    explicit FunctionPass (const void *pid):Pass (pid)

    {

    }

  };

  class PassInfo

  {

  public:typedef Pass *(*NormalCtor_t) ();

  private:const char *const PassName;

    const char *const PassArgument;

    const intptr_t PassID;

    const bool IsCFGOnlyPass;

    const bool IsAnalysis;

    const bool IsAnalysisGroup;

    NormalCtor_t NormalCtor;

  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),

      IsCFGOnlyPass (isCFGOnly), IsAnalysis (is_analysis),

      IsAnalysisGroup (false), NormalCtor (normal)

    {

    }

  };

  template < typename PassName > Pass * callDefaultCtor ()

  {

    return new PassName ();

  }

  template < typename passName > struct RegisterPass:public PassInfo

  {

  RegisterPass (const char *PassArg, const char *Name, bool CFGOnly = false, bool is_analysis = false):PassInfo (Name, PassArg, intptr_t (&passName::ID),

              PassInfo::NormalCtor_t (callDefaultCtor < passName >), CFGOnly,

              is_analysis)

    {

    }

  };

  template < typename T > class SmallVectorImpl

  {

  };

  template < typename T,

    unsigned N > class SmallVector:public SmallVectorImpl < T >

  {

  };

  class MachineFunctionPass:public FunctionPass

  {

  protected:explicit MachineFunctionPass (intptr_t ID):FunctionPass (ID)

    {

    }

    explicit MachineFunctionPass (void *ID):FunctionPass (ID)

    {

    }

    virtual bool runOnMachineFunction (MachineFunction & MF) = 0;

  };

  class LiveIndex

  {

  private:unsigned index;

  };

  class VNInfo

  {

  };

  struct LiveRange

  {

    LiveIndex start;

    LiveIndex end;

    VNInfo *valno;

  };

  class LiveInterval

  {

  public:typedef SmallVector < LiveRange, 4 > Ranges;

    bool containsOneValue () const

    {

    }

    LiveRange *getLiveRangeContaining (LiveIndex Idx)

    {

    }

    void removeRange (LiveIndex Start, LiveIndex End, bool RemoveDeadValNo =

                      false);

    void removeRange (LiveRange LR, bool RemoveDeadValNo = false)

    {

      removeRange (LR.start, LR.end, RemoveDeadValNo);

    }

  };

  class LiveIntervals:public MachineFunctionPass

  {

  public:static char ID;

    LiveIndex getDefIndex (LiveIndex index)

    {

    }

    LiveInterval & getInterval (unsigned reg)

    {

    }

    LiveIndex getInstructionIndex (const MachineInstr * instr) const

    {

    }

  };

}

using namespace llvm;

namespace

{

struct __attribute__ ((visibility ("hidden"))) StrongPHIElimination:public

    MachineFunctionPass

  {

    static char ID;

  StrongPHIElimination ():MachineFunctionPass (&ID)

    {

    }

    bool runOnMachineFunction (MachineFunction & Fn);

  };

}

static RegisterPass < StrongPHIElimination > X ("strong-phi-node-elimination",

                                                "Eliminate PHI nodes for register allocation, intelligently");

bool

StrongPHIElimination::runOnMachineFunction (MachineFunction & Fn)

{

  LiveIntervals & LI = getAnalysis < LiveIntervals > ();

  std::vector < MachineInstr * >phis;

  for (std::vector < MachineInstr * >::iterator I = phis.begin (), E =

       phis.end (); I != E;)

    {

      MachineInstr *PInstr = *(I++);

      unsigned DestReg = PInstr->getOperand (0).getReg ();

      LiveInterval & PI = LI.getInterval (DestReg);

      if (PInstr->registerDefIsDead (DestReg))

        {

          if (PI.containsOneValue ())

            {

              LiveIndex idx =

                LI.getDefIndex (LI.getInstructionIndex (PInstr));

              PI.removeRange (*PI.getLiveRangeContaining (idx), true);

            }

        }

    }

}