ShStatement.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright (c) 2003 University of Waterloo Computer Graphics Laboratory
// Project administrator: Michael D. McCool
// Authors: Zheng Qin, Stefanus Du Toit, Kevin Moule, Tiberiu S. Popa,
//          Michael D. McCool
// 
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// 
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 
// 1. The origin of this software must not be misrepresented; you must
// not claim that you wrote the original software. If you use this
// software in a product, an acknowledgment in the product documentation
// would be appreciated but is not required.
// 
// 2. Altered source versions must be plainly marked as such, and must
// not be misrepresented as being the original software.
// 
// 3. This notice may not be removed or altered from any source
// distribution.
#ifndef SHSTATEMENT_HPP
#define SHSTATEMENT_HPP

#include <iosfwd>
#include <set>
#include <list>
#include "ShDllExport.hpp"
#include "ShVariable.hpp"

namespace SH {

enum ShOperation {
  SH_OP_ASN, 
  
  SH_OP_NEG, 
  SH_OP_ADD, 
  SH_OP_MUL, 

  SH_OP_DIV, 

  // All of the following set dst to either 1 or 0.
  SH_OP_SLT, 
  SH_OP_SLE, 
  SH_OP_SGT, 
  SH_OP_SGE, 
  SH_OP_SEQ, 
  SH_OP_SNE, 
  
  SH_OP_ABS, 
  SH_OP_ACOS, 
  SH_OP_ASIN, 
  SH_OP_ATAN, 
  SH_OP_ATAN2, 
  SH_OP_CBRT, 
  SH_OP_CEIL, 
  SH_OP_COS, 
  SH_OP_CMUL, 
  SH_OP_CSUM, 
  SH_OP_DOT, 
  SH_OP_DX, 
  SH_OP_DY, 
  SH_OP_EXP, 
  SH_OP_EXP2, 
  SH_OP_EXP10, 
  SH_OP_FLR, 
  SH_OP_FRAC, 
  SH_OP_LRP, 
  SH_OP_MAD, 
  SH_OP_MAX, 
  SH_OP_MIN, 
  SH_OP_MOD, 
  SH_OP_LOG, 
  SH_OP_LOG2, 
  SH_OP_LOG10, 
  SH_OP_POW, 
  SH_OP_RCP, 
  SH_OP_RND, 
  SH_OP_RSQ, 
  SH_OP_SIN, 
  SH_OP_SGN, 
  SH_OP_SQRT, 
  SH_OP_TAN, 

  SH_OP_NORM, 
  SH_OP_XPD, 

  SH_OP_TEX, 
  SH_OP_TEXI, 
  SH_OP_TEXD, 

  SH_OP_COND, 

  SH_OP_KIL, 

  SH_OP_OPTBRA, 



  SH_OP_FETCH, 
};

#ifdef IGNORE
#undef IGNORE
#endif

struct
SH_DLLEXPORT ShOperationInfo {
  const char* name; 
  int arity; 

  enum ResultSource {
    LINEAR,   // dest[i] depends only on src_j[i] for all 0 <= j < arity
    ALL,      // dest[i] depends on all elements of src_j for all 0 <= j < arity
    EXTERNAL, // Statement yields its results from an external source
              // (e.g. TEX)
    IGNORE   // Does not yield a result
  } result_source;

  bool commutative; 
};

SH_DLLEXPORT
extern const ShOperationInfo opInfo[];

class 
SH_DLLEXPORT
ShStatementInfo {
public:
  virtual ~ShStatementInfo();

  virtual ShStatementInfo* clone() const = 0;
  
protected:
  ShStatementInfo();

};

class
SH_DLLEXPORT ShStatement {
public:
  ShStatement(ShVariable dest, ShOperation op);
  ShStatement(ShVariable dest, ShOperation op, ShVariable src);
  ShStatement(ShVariable dest, ShVariable src0, ShOperation op, ShVariable src1);
  ShStatement(ShVariable dest, ShOperation op, ShVariable src0, ShVariable src1, ShVariable src2);
  ShStatement(const ShStatement& other);
  
  ~ShStatement();

  ShStatement& operator=(const ShStatement& other);
  
  
  ShVariable dest;
  ShVariable src[3];
  
  ShOperation op;

  // Used by the optimizer and anything else that needs to store extra
  // information in statements.
  // Anything in here will be deleted when this statement is deleted.
  std::list<ShStatementInfo*> info;

  // Return the first entry in info whose type matches T, or 0 if no
  // such entry exists.
  template<typename T>
  T* get_info();

  // Delete and remove all info entries matching the given type.
  template<typename T>
  void destroy_info();

  // Add the given statement information to the end of the info list.
  void add_info(ShStatementInfo* new_info);

  // Remove the given statement information from the list.
  // Does not delete it, so be careful!
  void remove_info(ShStatementInfo* old_info);
  
  bool marked;
};

std::ostream& operator<<(std::ostream& out, const SH::ShStatement& stmt);

template<typename T>
T* ShStatement::get_info()
{
  for (std::list<ShStatementInfo*>::iterator I = info.begin(); I != info.end(); ++I) {
    T* item = dynamic_cast<T*>(*I);
    if (item) {
      return item;
    }
  }
  return 0;
}

template<typename T>
void ShStatement::destroy_info()
{
  for (std::list<ShStatementInfo*>::iterator I = info.begin(); I != info.end();) {
    T* item = dynamic_cast<T*>(*I);
    if (item) {
      I = info.erase(I);
      delete item;
    } else {
      ++I;
    }
  }
}

} // namespace SH

#endif

---