| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @author Intel, Pavel A. Ozhdikhin |
| * |
| */ |
| |
| #ifndef _OPNDMAP_H |
| #define _OPNDMAP_H |
| |
| #include <iostream> |
| #include "Stl.h" |
| |
| namespace Jitrino { |
| class Opnd; |
| |
| template <typename FromType, typename ToType> |
| class SparseScopedMap { |
| typedef StlHashMap<FromType, ToType> MapBase; |
| MapBase theMap; |
| StlVector<FromType> theList; // 0 separates scopes; |
| // priorValues has previous value for each non-0 elt in theList: |
| StlVector<ToType> priorValues; |
| FromType zero; |
| U_32 resize_when; |
| U_32 resize_by; |
| public: |
| SparseScopedMap(MemoryManager& mm) : |
| theMap(mm), |
| theList(mm), |
| priorValues(mm), |
| zero(0), |
| resize_when(4), |
| resize_by(7) |
| {}; |
| SparseScopedMap(size_t n, |
| MemoryManager& mm, |
| U_32 init_factor=1, |
| U_32 resize_factor=4, |
| U_32 resize_to=7) : |
| theMap(mm), |
| theList(mm), |
| priorValues(mm), |
| zero(0), |
| resize_when(resize_factor), |
| resize_by(resize_to) |
| { |
| theList.reserve(n); |
| priorValues.reserve(n); |
| }; |
| |
| ToType lookup(FromType o) { |
| typename MapBase::iterator found = theMap.find(o); |
| return (found != theMap.end()) ? (*found).second : ToType(0); |
| }; |
| void insert(FromType org, ToType to) { |
| ToType priorValue = theMap[org]; |
| theMap[org] = to; |
| theList.push_back(org); |
| priorValues.push_back(priorValue); |
| }; |
| void enter_scope() { |
| theList.push_back(zero); |
| }; |
| void exit_scope() { |
| FromType o; |
| do { |
| o = theList.back(); |
| theList.pop_back(); |
| if (o != zero) { |
| ToType priorValue = priorValues.back(); |
| priorValues.pop_back(); |
| if (priorValue != ToType(0)) { |
| theMap[o] = priorValue; |
| } else { |
| theMap.erase(o); |
| } |
| } |
| } while (o != zero); |
| }; |
| }; |
| |
| // |
| // Map from original Opnd to Opnd |
| // |
| |
| |
| class SparseOpndMap : public SparseScopedMap<Opnd *, Opnd *> { |
| public: |
| SparseOpndMap(MemoryManager& mm) : |
| SparseScopedMap<Opnd *, Opnd *>(mm) {}; |
| SparseOpndMap(size_t n, MemoryManager& mm, |
| U_32 init_factor, U_32 resize_factor, U_32 resize_to) : |
| SparseScopedMap<Opnd *, Opnd *>(n, mm, init_factor, resize_factor, |
| resize_to) {}; |
| Opnd *lookupTillEnd(Opnd *o) { |
| Opnd *found = lookup(o); |
| if (NULL == found) { |
| return NULL; |
| } |
| Opnd *foundMore; |
| while (NULL != (foundMore = lookup(found))) { |
| found = foundMore; |
| } |
| return found; |
| } |
| }; |
| |
| |
| } //namespace Jitrino |
| |
| #endif // _OPNDMAP_H |