1 // Copyright 2006-2008 the V8 project authors. All rights reserved. 2 // Redistribution and use in source and binary forms, with or without 3 // modification, are permitted provided that the following conditions are 4 // met: 5 // 6 // * Redistributions of source code must retain the above copyright 7 // notice, this list of conditions and the following disclaimer. 8 // * Redistributions in binary form must reproduce the above 9 // copyright notice, this list of conditions and the following 10 // disclaimer in the documentation and/or other materials provided 11 // with the distribution. 12 // * Neither the name of Google Inc. nor the names of its 13 // contributors may be used to endorse or promote products derived 14 // from this software without specific prior written permission. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 28 #ifndef V8_VARIABLES_H_ 29 #define V8_VARIABLES_H_ 30 31 #include "zone.h" 32 33 namespace v8 { 34 namespace internal { 35 36 class UseCount BASE_EMBEDDED { 37 public: 38 UseCount(); 39 40 // Inform the node of a "use". The weight can be used to indicate 41 // heavier use, for instance if the variable is accessed inside a loop. 42 void RecordRead(int weight); 43 void RecordWrite(int weight); 44 void RecordAccess(int weight); // records a read & write 45 void RecordUses(UseCount* uses); 46 nreads()47 int nreads() const { return nreads_; } nwrites()48 int nwrites() const { return nwrites_; } nuses()49 int nuses() const { return nreads_ + nwrites_; } 50 is_read()51 bool is_read() const { return nreads() > 0; } is_written()52 bool is_written() const { return nwrites() > 0; } is_used()53 bool is_used() const { return nuses() > 0; } 54 55 #ifdef DEBUG 56 void Print(); 57 #endif 58 59 private: 60 int nreads_; 61 int nwrites_; 62 }; 63 64 65 // Variables and AST expression nodes can track their "type" to enable 66 // optimizations and removal of redundant checks when generating code. 67 68 class SmiAnalysis { 69 public: 70 enum Kind { 71 UNKNOWN, 72 LIKELY_SMI 73 }; 74 SmiAnalysis()75 SmiAnalysis() : kind_(UNKNOWN) {} 76 Is(Kind kind)77 bool Is(Kind kind) const { return kind_ == kind; } 78 IsKnown()79 bool IsKnown() const { return !Is(UNKNOWN); } IsUnknown()80 bool IsUnknown() const { return Is(UNKNOWN); } IsLikelySmi()81 bool IsLikelySmi() const { return Is(LIKELY_SMI); } 82 CopyFrom(SmiAnalysis * other)83 void CopyFrom(SmiAnalysis* other) { 84 kind_ = other->kind_; 85 } 86 87 static const char* Type2String(SmiAnalysis* type); 88 89 // LIKELY_SMI accessors SetAsLikelySmi()90 void SetAsLikelySmi() { 91 kind_ = LIKELY_SMI; 92 } 93 SetAsLikelySmiIfUnknown()94 void SetAsLikelySmiIfUnknown() { 95 if (IsUnknown()) { 96 SetAsLikelySmi(); 97 } 98 } 99 100 private: 101 Kind kind_; 102 103 DISALLOW_COPY_AND_ASSIGN(SmiAnalysis); 104 }; 105 106 107 // The AST refers to variables via VariableProxies - placeholders for the actual 108 // variables. Variables themselves are never directly referred to from the AST, 109 // they are maintained by scopes, and referred to from VariableProxies and Slots 110 // after binding and variable allocation. 111 112 class Variable: public ZoneObject { 113 public: 114 enum Mode { 115 // User declared variables: 116 VAR, // declared via 'var', and 'function' declarations 117 118 CONST, // declared via 'const' declarations 119 120 // Variables introduced by the compiler: 121 DYNAMIC, // always require dynamic lookup (we don't know 122 // the declaration) 123 124 DYNAMIC_GLOBAL, // requires dynamic lookup, but we know that the 125 // variable is global unless it has been shadowed 126 // by an eval-introduced variable 127 128 DYNAMIC_LOCAL, // requires dynamic lookup, but we know that the 129 // variable is local and where it is unless it 130 // has been shadowed by an eval-introduced 131 // variable 132 133 INTERNAL, // like VAR, but not user-visible (may or may not 134 // be in a context) 135 136 TEMPORARY // temporary variables (not user-visible), never 137 // in a context 138 }; 139 140 enum Kind { 141 NORMAL, 142 THIS, 143 ARGUMENTS 144 }; 145 146 Variable(Scope* scope, 147 Handle<String> name, 148 Mode mode, 149 bool is_valid_lhs, 150 Kind kind); 151 152 // Printing support 153 static const char* Mode2String(Mode mode); 154 155 // Type testing & conversion 156 Property* AsProperty(); 157 Variable* AsVariable(); IsValidLeftHandSide()158 bool IsValidLeftHandSide() { return is_valid_LHS_; } 159 160 // The source code for an eval() call may refer to a variable that is 161 // in an outer scope about which we don't know anything (it may not 162 // be the global scope). scope() is NULL in that case. Currently the 163 // scope is only used to follow the context chain length. scope()164 Scope* scope() const { return scope_; } 165 name()166 Handle<String> name() const { return name_; } mode()167 Mode mode() const { return mode_; } is_accessed_from_inner_scope()168 bool is_accessed_from_inner_scope() const { 169 return is_accessed_from_inner_scope_; 170 } var_uses()171 UseCount* var_uses() { return &var_uses_; } obj_uses()172 UseCount* obj_uses() { return &obj_uses_; } 173 IsVariable(Handle<String> n)174 bool IsVariable(Handle<String> n) { 175 return !is_this() && name().is_identical_to(n); 176 } 177 is_dynamic()178 bool is_dynamic() const { 179 return (mode_ == DYNAMIC || 180 mode_ == DYNAMIC_GLOBAL || 181 mode_ == DYNAMIC_LOCAL); 182 } 183 184 bool is_global() const; is_this()185 bool is_this() const { return kind_ == THIS; } is_arguments()186 bool is_arguments() const { return kind_ == ARGUMENTS; } 187 local_if_not_shadowed()188 Variable* local_if_not_shadowed() const { 189 ASSERT(mode_ == DYNAMIC_LOCAL && local_if_not_shadowed_ != NULL); 190 return local_if_not_shadowed_; 191 } 192 set_local_if_not_shadowed(Variable * local)193 void set_local_if_not_shadowed(Variable* local) { 194 local_if_not_shadowed_ = local; 195 } 196 rewrite()197 Expression* rewrite() const { return rewrite_; } 198 Slot* slot() const; 199 type()200 SmiAnalysis* type() { return &type_; } 201 202 private: 203 Scope* scope_; 204 Handle<String> name_; 205 Mode mode_; 206 bool is_valid_LHS_; 207 Kind kind_; 208 209 Variable* local_if_not_shadowed_; 210 211 // Usage info. 212 bool is_accessed_from_inner_scope_; // set by variable resolver 213 UseCount var_uses_; // uses of the variable value 214 UseCount obj_uses_; // uses of the object the variable points to 215 216 // Static type information 217 SmiAnalysis type_; 218 219 // Code generation. 220 // rewrite_ is usually a Slot or a Property, but may be any expression. 221 Expression* rewrite_; 222 223 friend class Scope; // Has explicit access to rewrite_. 224 }; 225 226 227 } } // namespace v8::internal 228 229 #endif // V8_VARIABLES_H_ 230