src/lithium-inl.h

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_LITHIUM_INL_H_
   6 #define V8_LITHIUM_INL_H_
   7
   8 #include "src/lithium.h"
   9
  10 #if V8_TARGET_ARCH_IA32
  11 #include "src/ia32/lithium-ia32.h"  // NOLINT
  12 #elif V8_TARGET_ARCH_X64
  13 #include "src/x64/lithium-x64.h"  // NOLINT
  14 #elif V8_TARGET_ARCH_ARM64
  15 #include "src/arm64/lithium-arm64.h"  // NOLINT
  16 #elif V8_TARGET_ARCH_ARM
  17 #include "src/arm/lithium-arm.h"  // NOLINT
  18 #elif V8_TARGET_ARCH_MIPS
  19 #include "src/mips/lithium-mips.h"  // NOLINT
  20 #elif V8_TARGET_ARCH_MIPS64
  21 #include "src/mips64/lithium-mips64.h"  // NOLINT
  22 #elif V8_TARGET_ARCH_X87
  23 #include "src/x87/lithium-x87.h"  // NOLINT
  24 #else
  25 #error "Unknown architecture."
  26 #endif
  27
  28 namespace v8 {
  29 namespace internal {
  30
  31 TempIterator::TempIterator(LInstruction* instr)
  32     : instr_(instr), limit_(instr->TempCount()), current_(0) {
  33   SkipUninteresting();
  34 }
  35
  36
  37 bool TempIterator::Done() { return current_ >= limit_; }
  38
  39
  40 LOperand* TempIterator::Current() {
  41   ASSERT(!Done());
  42   return instr_->TempAt(current_);
  43 }
  44
  45
  46 void TempIterator::SkipUninteresting() {
  47   while (current_ < limit_ && instr_->TempAt(current_) == NULL) ++current_;
  48 }
  49
  50
  51 void TempIterator::Advance() {
  52   ++current_;
  53   SkipUninteresting();
  54 }
  55
  56
  57 InputIterator::InputIterator(LInstruction* instr)
  58     : instr_(instr), limit_(instr->InputCount()), current_(0) {
  59   SkipUninteresting();
  60 }
  61
  62
  63 bool InputIterator::Done() { return current_ >= limit_; }
  64
  65
  66 LOperand* InputIterator::Current() {
  67   ASSERT(!Done());
  68   ASSERT(instr_->InputAt(current_) != NULL);
  69   return instr_->InputAt(current_);
  70 }
  71
  72
  73 void InputIterator::Advance() {
  74   ++current_;
  75   SkipUninteresting();
  76 }
  77
  78
  79 void InputIterator::SkipUninteresting() {
  80   while (current_ < limit_) {
  81     LOperand* current = instr_->InputAt(current_);
  82     if (current != NULL && !current->IsConstantOperand()) break;
  83     ++current_;
  84   }
  85 }
  86
  87
  88 UseIterator::UseIterator(LInstruction* instr)
  89     : input_iterator_(instr), env_iterator_(instr->environment()) {}
  90
  91
  92 bool UseIterator::Done() {
  93   return input_iterator_.Done() && env_iterator_.Done();
  94 }
  95
  96
  97 LOperand* UseIterator::Current() {
  98   ASSERT(!Done());
  99   LOperand* result = input_iterator_.Done() ? env_iterator_.Current()
 100                                             : input_iterator_.Current();
 101   ASSERT(result != NULL);
 102   return result;
 103 }
 104
 105
 106 void UseIterator::Advance() {
 107   input_iterator_.Done() ? env_iterator_.Advance() : input_iterator_.Advance();
 108 }
 109 }
 110 }  // namespace v8::internal
 111
 112 #endif  // V8_LITHIUM_INL_H_