hphp/runtime/vm/jit/ir-instr-table.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 #ifndef incl_HPHP_IR_INSTR_TABLE_H_
  18 #define incl_HPHP_IR_INSTR_TABLE_H_
  19
  20 #include <unordered_map>
  21
  22 #include <folly/Hash.h>
  23
  24 #include "hphp/runtime/vm/jit/ir-instruction.h"
  25 #include "hphp/runtime/vm/jit/ssa-tmp.h"
  26
  27 namespace HPHP { namespace jit {
  28 ///////////////////////////////////////////////////////////////////////////////
  29
  30 /*
  31  * Hash table used for IRUnit constants.
  32  *
  33  * The table maps IRInstructions to SSATmps.  Instructions are considered to
  34  * be the same iff their inputs and parameters are the same.
  35  */
  36 struct IRInstrTable {
  37   SSATmp* lookup(IRInstruction* inst) const {
  38     auto const it = m_map.find(inst);
  39     if (it == m_map.end()) return nullptr;
  40     return it->second;
  41   }
  42   SSATmp* insert(SSATmp* opnd) {
  43     return m_map[opnd->inst()] = opnd;
  44   }
  45   void erase(SSATmp* opnd) {
  46     m_map.erase(opnd->inst());
  47   }
  48   void clear() {
  49     m_map.clear();
  50   }
  51
  52 private:
  53   struct EqualsOp {
  54     bool operator()(const IRInstruction* i1,
  55                     const IRInstruction* i2) const {
  56       if (i1->op()           != i2->op() ||
  57           i1->hasTypeParam() != i2->hasTypeParam() ||
  58           i1->numSrcs()      != i2->numSrcs() ||
  59           i1->hasExtra()     != i2->hasExtra()) {
  60         return false;
  61       }
  62       if (i1->hasTypeParam()) {
  63         if (i1->typeParam() != i2->typeParam()) return false;
  64       }
  65       for (uint32_t i = 0; i < i1->numSrcs(); ++i) {
  66         if (i1->src(i) != i2->src(i)) {
  67           return false;
  68         }
  69       }
  70       if (i1->hasExtra()) {
  71         return equalsExtra(i1->op(), i1->rawExtra(), i2->rawExtra());
  72       }
  73       return true;
  74     }
  75   };
  76
  77   struct HashOp {
  78     size_t hash(const IRInstruction* inst) const {
  79       size_t h = 0;
  80       for (uint32_t i = 0; i < inst->numSrcs(); ++i) {
  81         h = hash_combine(h, inst->src(i));
  82       }
  83       if (inst->hasExtra()) {
  84         h = hash_combine(h, hashExtra(inst->op(), inst->rawExtra()));
  85       }
  86       if (inst->hasTypeParam()) {
  87         h = hash_combine(h, inst->typeParam());
  88       }
  89       return hash_combine(h, inst->op());
  90     }
  91     size_t operator()(IRInstruction* inst) const {
  92       return hash(inst);
  93     }
  94
  95   private:
  96     template<class T>
  97     static size_t hash_combine(size_t base, T other) {
  98       return folly::hash::hash_128_to_64(
  99           base, folly::hash::hash_combine(other));
 100     }
 101   };
 102
 103 private:
 104   std::unordered_map<IRInstruction*,SSATmp*,HashOp,EqualsOp> m_map;
 105 };
 106
 107 ///////////////////////////////////////////////////////////////////////////////
 108 }}
 109
 110 #endif