IntrinsicXlationTable.h

Go to the documentation of this file.

// -*-Mode: C++;-*-
// $Header: /Volumes/cvsrep/developer/OpenADFortTk/src/IntrinsicXlationTable.h,v 1.8 2006/05/12 16:12:22 utke Exp $


#ifndef IntrinsicXlationTable_H 
#define IntrinsicXlationTable_H

#include <iostream>
#include <vector>

#include "Open64IRInterface/Open64BasicTypes.h"


namespace fortTkSupport { 

  class IntrinsicXlationTable {
  public:
  
    enum TableType { 
      W2X, // A table optimized for WHIRL->XAIF lookups
      X2W  // A table optimized for XAIF->WHIRL lookups
    };

    enum WNOprClass {
      WNCall             =0, // A WHIRL function or subroutine call
      WNIntrinCall       =1, // A WHIRL intrinsics call
      WNIntrinOp         =2, // A WHIRL intrinsics operation
      WNExpr             =3, // A WHIRL expression
      WNOprClass_UNKNOWN =4  // special, reserved for searching table
    };

    static const std::string toString(const WNOprClass& oprcl);
  
    enum XAIFOpr {
      XAIFSubCall,
      XAIFFuncCall,
      XAIFIntrin,
      XAIFBoolOp,
      XAIFOpr_UNKNOWN   // special, reserved for searching table
    };

    static const std::string toString(const XAIFOpr& opr);

    struct WHIRLInfo {
      WNOprClass oprcl;   // class of the WN operator
      OPERATOR opr;       // the WN operator
      const char* name;   // string qualifier for calls
      unsigned int numop; // number of operands to intrinsic
      unsigned int numOptional; // number of optional arguments
      void dump(std::ostream& os = std::cerr) const;
      void ddump() const;
    };
  
    struct XAIFInfo {
      XAIFOpr opr;        // the XAIF 'operator'
      const char* name;   // intrinsic name
      const char* key;    // disambiguates otherwise identical xaif intrinsics
      unsigned int numop; // number of operands to intrinsic
      void dump(std::ostream& os = std::cerr) const;
      void ddump() const;
    };

    struct Entry {
      WHIRLInfo whirl_info;
      XAIFInfo xaif_info;
    };

  public:
    IntrinsicXlationTable(const TableType& tt);

    ~IntrinsicXlationTable();

    struct XAIFInfoPair {  
      XAIFInfoPair(bool aBoolean,
                   const XAIFInfo& anXAIFInfo);
      bool first;
      const XAIFInfo& second;
    private:
      XAIFInfoPair();
    };

    XAIFInfoPair findXAIFInfo(OPERATOR opr, const char* name, bool mustFind=true);
    
    WHIRLInfo* findWHIRLInfo(XAIFOpr opr, const char* name, const char* key);

    void dump(std::ostream& os = std::cerr) const;
    void ddump() const;

  private:

    IntrinsicXlationTable(const IntrinsicXlationTable& p);

    IntrinsicXlationTable& operator=(const IntrinsicXlationTable& p);

    class LtSortedTable {
    public:
      LtSortedTable(TableType aTableType, bool ignoreXaifKey=false); 
      ~LtSortedTable();

      // return true if e1 < e2; false otherwise
      bool operator()(const Entry* e1, const Entry* e2) const;

      // required for binary_search(..), lower_bound(..) on GCC 3.3 (?!)
      bool operator()(Entry*& e1, const Entry& e2) {
        return operator()(dynamic_cast<Entry*>(e1), 
                          dynamic_cast<const Entry*>(&e2));
      }
      bool operator()(const Entry& e1, Entry*& e2) {
        return operator()(dynamic_cast<const Entry*>(&e1), 
                          dynamic_cast<Entry*>(e2));
      }
    
      // required for binary_search(..), lower_bound(..) on GCC 3.3 (?!)
      bool operator()(const Entry& e1, const Entry& e2) {
        return operator()(dynamic_cast<const Entry*>(&e1), 
                          dynamic_cast<const Entry*>(&e2));
      }
      bool operator()(const Entry*& e1, const Entry*& e2) {
        return operator()(dynamic_cast<const Entry*>(e1), 
                          dynamic_cast<const Entry*>(e2));
      }
    
    private:
      LtSortedTable();
    
    private:
      TableType myTableType;         // sorting type
      bool      myIgnoreXaifKeyFlag; // only meaningful in X2W mode
    };
  
    typedef std::vector<Entry*>     SortedTable;
    typedef SortedTable::iterator   SortedTableIt;
    typedef SortedTable::value_type SortedTableVal;

  private:
  
    TableType   myTableType;
    SortedTable mySortedTable;
  
    static Entry        ourTable[];
    static unsigned int ourTableSize;

  };

} 

#endif