osprey/be/lno/cond.h

Go to the documentation of this file.

/*
 * Copyright 2005, 2006 PathScale, Inc.  All Rights Reserved.
 */

/*
  Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.

  This program is free software; you can redistribute it and/or modify it
  under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it would be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

  Further, this software is distributed without any warranty that it is
  free of the rightful claim of any third person regarding infringement 
  or the like.  Any license provided herein, whether implied or 
  otherwise, applies only to this software file.  Patent licenses, if 
  any, provided herein do not apply to combinations of this program with 
  other software, or any other product whatsoever.  

  You should have received a copy of the GNU General Public License along
  with this program; if not, write the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston MA 02111-1307, USA.

  Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
  Mountain View, CA 94043, or:

  http://www.sgi.com

  For further information regarding this notice, see:

  http://oss.sgi.com/projects/GenInfo/NoticeExplan

*/


// -*-C++-*-

#ifndef _defs_INCLUDED
#include "defs.h"
#endif

#ifndef access_vector_INCLUDED
#include "access_vector.h"
#endif

#ifndef soe_INCLUDED
#include "soe.h"
#endif

#ifndef fb_whirl_INCLUDED
#include "fb_whirl.h"
#endif

#ifndef cond_INCLUDED
#define cond_INCLUDED "cond.h"

class WN;
typedef struct mem_pool MEM_POOL;

#ifdef _KEEP_RCS_ID
static char *cond_rcs_id = cond_INCLUDED "$Revision: 1.6 $";
#endif /* _KEEP_RCS_ID */

enum COND_IF_INFO {COND_IF_THEN_ONLY, COND_IF_ELSE_ONLY, COND_IF_NOT_SURE};
enum COND_DO_INFO {COND_DO_AT_LEAST_ONCE, COND_DO_NEVER, COND_DO_MAYBE};

extern COND_IF_INFO COND_If_Info(WN* wn_if, MEM_POOL* =0);
extern COND_DO_INFO COND_Do_Info(WN* wn_do, MEM_POOL* = 0);

extern void COND_Test(WN*);
extern BOOL Eliminate_Dead_SCF(WN *wn, void Remove_Region(WN *));
void Guard_Dos(WN *func_nd);
BOOL Hoist_Conditionals(WN *func_nd);
BOOL Is_Consistent_Condition(ACCESS_VECTOR *av, WN *expr);
extern WN* Guard_A_Do(WN *do_wn); 
extern void Canonicalize_Unsigned_Loops(WN* func_nd);
extern void Update_Guarded_Do_FB(WN *if_wn, WN *do_wn, FEEDBACK *feedback);
#ifdef KEY
extern BOOL Loop_Unswitch_SCF(WN *wn);
#endif

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// COND_BOUNDS_INFO
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

class COND_SYMBOL_INFO {

 public:

  SYMBOL        Symbol;
  WN*           Outer_Nondef;
  COND_SYMBOL_INFO(SYMBOL s, WN* o) : Symbol(s), Outer_Nondef(o) {}
  COND_SYMBOL_INFO() : Symbol(), Outer_Nondef(NULL) {}
  COND_SYMBOL_INFO& operator = (const COND_SYMBOL_INFO& a)
    {Symbol = a.Symbol; Outer_Nondef = a.Outer_Nondef; return *this;}
  ~COND_SYMBOL_INFO() {}
  void Print(FILE*) const;
};

class COND_BOUNDS_INFO {

 public:

  COND_BOUNDS_INFO(MEM_POOL*);
  ~COND_BOUNDS_INFO();

  void          Collect_Outer_Info(WN* parent, WN* child = NULL);
  void          Collect_Do_Info(WN* wn_do);
  void          Collect_If_Info(WN* wn_if, BOOL);

  // all information known about the bounds.  This includes the outer
  // loops and conditionals.  All facts.

  SYSTEM_OF_EQUATIONS&          Bounds() {return _bounds;}
  const SYSTEM_OF_EQUATIONS&    Bounds() const {return _bounds;}

  STACK<COND_SYMBOL_INFO>&      Symbol_Info() {return _symbol_info;}
  const STACK<COND_SYMBOL_INFO>&Symbol_Info() const {return _symbol_info;}

  MEM_POOL*                     Pool() const {return _pool;}

  // Given the access array or vector, add the equations expressed.

  INT           Add_Access(ACCESS_VECTOR* av, WN* code, WN* control);
  INT           Add_Access(ACCESS_ARRAY* ai, WN* code, WN* control);

  void          Reset_Bounds_To(INT, INT, INT, DYN_ARRAY<WN*>*);
  void          Print(FILE*) const;

 private:

  void          Reset_Varcount_To(INT cols);


  // Add_Access helper function
  INT           Lookup_Entry(SYMBOL, WN*);
  void          Kill_Written_Symbols(ACCESS_VECTOR*, WN* code, WN* control);

  // undefined
  COND_BOUNDS_INFO();
  COND_BOUNDS_INFO&             operator = (const COND_BOUNDS_INFO&);
  COND_BOUNDS_INFO(const COND_BOUNDS_INFO&);

  SYSTEM_OF_EQUATIONS           _bounds;
  STACK<COND_SYMBOL_INFO>       _symbol_info;
  MEM_POOL*                     _pool;
};

extern BOOL Redundant_Condition(COND_BOUNDS_INFO* info, WN* wn_cond,
  WN* wn_if);

#ifdef TARG_X8664
extern BOOL Is_Vectorizable_Loop(WN* loop);
#endif
#endif

---