← Back to branch summary

~evarlast/ubuntu/utopic/mongodb/upstart-workaround-debian-bug-718702

« back to all changes in this revision

Viewing changes to src/third_party/v8/src/type-info.h

  • Committer: Package Import Robot
  • Author(s): James Page, James Page, Robie Basak
  • Date: 2013-05-29 17:44:42 UTC
  • mfrom: (44.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20130529174442-z0a4qmoww4y0t458
Tags: 1:2.4.3-1ubuntu1
[ James Page ]
* Merge from Debian unstable, remaining changes:
  - Enable SSL support:
    + d/control: Add libssl-dev to BD's.
    + d/rules: Enabled --ssl option.
    + d/mongodb.conf: Add example SSL configuration options.
  - d/mongodb-server.mongodb.upstart: Add upstart configuration.
  - d/rules: Don't strip binaries during scons build for Ubuntu.
  - d/control: Add armhf to target archs.
  - d/p/SConscript.client.patch: fixup install of client libraries.
  - d/p/0010-install-libs-to-usr-lib-not-usr-lib64-Closes-588557.patch:
    Install libraries to lib not lib64.
* Dropped changes:
  - d/p/arm-support.patch: Included in Debian.
  - d/p/double-alignment.patch: Included in Debian.
  - d/rules,control: Debian also builds with avaliable system libraries
    now.
* Fix FTBFS due to gcc and boost upgrades in saucy:
  - d/p/0008-ignore-unused-local-typedefs.patch: Add -Wno-unused-typedefs
    to unbreak building with g++-4.8.
  - d/p/0009-boost-1.53.patch: Fixup signed/unsigned casting issue.

[ Robie Basak ]
* d/p/0011-Use-a-signed-char-to-store-BSONType-enumerations.patch: Fixup
  build failure on ARM due to missing signed'ness of char cast.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/third_party/v8/src/type-info.h
 
1
// Copyright 2012 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_TYPE_INFO_H_
 
29
#define V8_TYPE_INFO_H_
 
30
 
 
31
#include "allocation.h"
 
32
#include "ast.h"
 
33
#include "globals.h"
 
34
#include "zone-inl.h"
 
35
 
 
36
namespace v8 {
 
37
namespace internal {
 
38
 
 
39
const int kMaxKeyedPolymorphism = 4;
 
40
 
 
41
//         Unknown
 
42
//           |   \____________
 
43
//           |                |
 
44
//      Primitive       Non-primitive
 
45
//           |   \_______     |
 
46
//           |           |    |
 
47
//        Number       String |
 
48
//         /   \         |    |
 
49
//    Double  Integer32  |   /
 
50
//        |      |      /   /
 
51
//        |     Smi    /   /
 
52
//        |      |    / __/
 
53
//        Uninitialized.
 
54
 
 
55
class TypeInfo {
 
56
 public:
 
57
  TypeInfo() : type_(kUninitialized) { }
 
58
 
 
59
  static TypeInfo Unknown() { return TypeInfo(kUnknown); }
 
60
  // We know it's a primitive type.
 
61
  static TypeInfo Primitive() { return TypeInfo(kPrimitive); }
 
62
  // We know it's a number of some sort.
 
63
  static TypeInfo Number() { return TypeInfo(kNumber); }
 
64
  // We know it's a signed 32 bit integer.
 
65
  static TypeInfo Integer32() { return TypeInfo(kInteger32); }
 
66
  // We know it's a Smi.
 
67
  static TypeInfo Smi() { return TypeInfo(kSmi); }
 
68
  // We know it's a Symbol.
 
69
  static TypeInfo Symbol() { return TypeInfo(kSymbol); }
 
70
  // We know it's a heap number.
 
71
  static TypeInfo Double() { return TypeInfo(kDouble); }
 
72
  // We know it's a string.
 
73
  static TypeInfo String() { return TypeInfo(kString); }
 
74
  // We know it's a non-primitive (object) type.
 
75
  static TypeInfo NonPrimitive() { return TypeInfo(kNonPrimitive); }
 
76
  // We haven't started collecting info yet.
 
77
  static TypeInfo Uninitialized() { return TypeInfo(kUninitialized); }
 
78
 
 
79
  int ToInt() {
 
80
    return type_;
 
81
  }
 
82
 
 
83
  static TypeInfo FromInt(int bit_representation) {
 
84
    Type t = static_cast<Type>(bit_representation);
 
85
    ASSERT(t == kUnknown ||
 
86
           t == kPrimitive ||
 
87
           t == kNumber ||
 
88
           t == kInteger32 ||
 
89
           t == kSmi ||
 
90
           t == kDouble ||
 
91
           t == kString ||
 
92
           t == kNonPrimitive);
 
93
    return TypeInfo(t);
 
94
  }
 
95
 
 
96
  // Return the weakest (least precise) common type.
 
97
  static TypeInfo Combine(TypeInfo a, TypeInfo b) {
 
98
    return TypeInfo(static_cast<Type>(a.type_ & b.type_));
 
99
  }
 
100
 
 
101
 
 
102
  // Integer32 is an integer that can be represented as a signed
 
103
  // 32-bit integer. It has to be
 
104
  // in the range [-2^31, 2^31 - 1]. We also have to check for negative 0
 
105
  // as it is not an Integer32.
 
106
  static inline bool IsInt32Double(double value) {
 
107
    const DoubleRepresentation minus_zero(-0.0);
 
108
    DoubleRepresentation rep(value);
 
109
    if (rep.bits == minus_zero.bits) return false;
 
110
    if (value >= kMinInt && value <= kMaxInt &&
 
111
        value == static_cast<int32_t>(value)) {
 
112
      return true;
 
113
    }
 
114
    return false;
 
115
  }
 
116
 
 
117
  static TypeInfo TypeFromValue(Handle<Object> value);
 
118
 
 
119
  bool Equals(const TypeInfo& other) {
 
120
    return type_ == other.type_;
 
121
  }
 
122
 
 
123
  inline bool IsUnknown() {
 
124
    ASSERT(type_ != kUninitialized);
 
125
    return type_ == kUnknown;
 
126
  }
 
127
 
 
128
  inline bool IsPrimitive() {
 
129
    ASSERT(type_ != kUninitialized);
 
130
    return ((type_ & kPrimitive) == kPrimitive);
 
131
  }
 
132
 
 
133
  inline bool IsNumber() {
 
134
    ASSERT(type_ != kUninitialized);
 
135
    return ((type_ & kNumber) == kNumber);
 
136
  }
 
137
 
 
138
  inline bool IsSmi() {
 
139
    ASSERT(type_ != kUninitialized);
 
140
    return ((type_ & kSmi) == kSmi);
 
141
  }
 
142
 
 
143
  inline bool IsSymbol() {
 
144
    ASSERT(type_ != kUninitialized);
 
145
    return ((type_ & kSymbol) == kSymbol);
 
146
  }
 
147
 
 
148
  inline bool IsNonSymbol() {
 
149
    ASSERT(type_ != kUninitialized);
 
150
    return ((type_ & kSymbol) == kString);
 
151
  }
 
152
 
 
153
  inline bool IsInteger32() {
 
154
    ASSERT(type_ != kUninitialized);
 
155
    return ((type_ & kInteger32) == kInteger32);
 
156
  }
 
157
 
 
158
  inline bool IsDouble() {
 
159
    ASSERT(type_ != kUninitialized);
 
160
    return ((type_ & kDouble) == kDouble);
 
161
  }
 
162
 
 
163
  inline bool IsString() {
 
164
    ASSERT(type_ != kUninitialized);
 
165
    return ((type_ & kString) == kString);
 
166
  }
 
167
 
 
168
  inline bool IsNonPrimitive() {
 
169
    ASSERT(type_ != kUninitialized);
 
170
    return ((type_ & kNonPrimitive) == kNonPrimitive);
 
171
  }
 
172
 
 
173
  inline bool IsUninitialized() {
 
174
    return type_ == kUninitialized;
 
175
  }
 
176
 
 
177
  const char* ToString() {
 
178
    switch (type_) {
 
179
      case kUnknown: return "Unknown";
 
180
      case kPrimitive: return "Primitive";
 
181
      case kNumber: return "Number";
 
182
      case kInteger32: return "Integer32";
 
183
      case kSmi: return "Smi";
 
184
      case kSymbol: return "Symbol";
 
185
      case kDouble: return "Double";
 
186
      case kString: return "String";
 
187
      case kNonPrimitive: return "Object";
 
188
      case kUninitialized: return "Uninitialized";
 
189
    }
 
190
    UNREACHABLE();
 
191
    return "Unreachable code";
 
192
  }
 
193
 
 
194
 private:
 
195
  enum Type {
 
196
    kUnknown = 0,          // 0000000
 
197
    kPrimitive = 0x10,     // 0010000
 
198
    kNumber = 0x11,        // 0010001
 
199
    kInteger32 = 0x13,     // 0010011
 
200
    kSmi = 0x17,           // 0010111
 
201
    kDouble = 0x19,        // 0011001
 
202
    kString = 0x30,        // 0110000
 
203
    kSymbol = 0x32,        // 0110010
 
204
    kNonPrimitive = 0x40,  // 1000000
 
205
    kUninitialized = 0x7f  // 1111111
 
206
  };
 
207
  explicit inline TypeInfo(Type t) : type_(t) { }
 
208
 
 
209
  Type type_;
 
210
};
 
211
 
 
212
 
 
213
enum StringStubFeedback {
 
214
  DEFAULT_STRING_STUB = 0,
 
215
  STRING_INDEX_OUT_OF_BOUNDS = 1
 
216
};
 
217
 
 
218
 
 
219
// Forward declarations.
 
220
class Assignment;
 
221
class BinaryOperation;
 
222
class Call;
 
223
class CallNew;
 
224
class CaseClause;
 
225
class CompareOperation;
 
226
class CompilationInfo;
 
227
class CountOperation;
 
228
class Expression;
 
229
class Property;
 
230
class SmallMapList;
 
231
class UnaryOperation;
 
232
class ForInStatement;
 
233
 
 
234
 
 
235
class TypeFeedbackOracle: public ZoneObject {
 
236
 public:
 
237
  TypeFeedbackOracle(Handle<Code> code,
 
238
                     Handle<Context> global_context,
 
239
                     Isolate* isolate,
 
240
                     Zone* zone);
 
241
 
 
242
  bool LoadIsMonomorphicNormal(Property* expr);
 
243
  bool LoadIsUninitialized(Property* expr);
 
244
  bool LoadIsMegamorphicWithTypeInfo(Property* expr);
 
245
  bool StoreIsMonomorphicNormal(Expression* expr);
 
246
  bool StoreIsMegamorphicWithTypeInfo(Expression* expr);
 
247
  bool CallIsMonomorphic(Call* expr);
 
248
  bool CallNewIsMonomorphic(CallNew* expr);
 
249
  bool ObjectLiteralStoreIsMonomorphic(ObjectLiteral::Property* prop);
 
250
 
 
251
  bool IsForInFastCase(ForInStatement* expr);
 
252
 
 
253
  Handle<Map> LoadMonomorphicReceiverType(Property* expr);
 
254
  Handle<Map> StoreMonomorphicReceiverType(Expression* expr);
 
255
 
 
256
  void LoadReceiverTypes(Property* expr,
 
257
                         Handle<String> name,
 
258
                         SmallMapList* types);
 
259
  void StoreReceiverTypes(Assignment* expr,
 
260
                          Handle<String> name,
 
261
                          SmallMapList* types);
 
262
  void CallReceiverTypes(Call* expr,
 
263
                         Handle<String> name,
 
264
                         CallKind call_kind,
 
265
                         SmallMapList* types);
 
266
  void CollectKeyedReceiverTypes(unsigned ast_id,
 
267
                                 SmallMapList* types);
 
268
 
 
269
  static bool CanRetainOtherContext(Map* map, Context* global_context);
 
270
  static bool CanRetainOtherContext(JSFunction* function,
 
271
                                    Context* global_context);
 
272
 
 
273
  CheckType GetCallCheckType(Call* expr);
 
274
  Handle<JSObject> GetPrototypeForPrimitiveCheck(CheckType check);
 
275
 
 
276
  Handle<JSFunction> GetCallTarget(Call* expr);
 
277
  Handle<JSFunction> GetCallNewTarget(CallNew* expr);
 
278
 
 
279
  Handle<Map> GetObjectLiteralStoreMap(ObjectLiteral::Property* prop);
 
280
 
 
281
  bool LoadIsBuiltin(Property* expr, Builtins::Name id);
 
282
 
 
283
  // TODO(1571) We can't use ToBooleanStub::Types as the return value because
 
284
  // of various cylces in our headers. Death to tons of implementations in
 
285
  // headers!! :-P
 
286
  byte ToBooleanTypes(unsigned ast_id);
 
287
 
 
288
  // Get type information for arithmetic operations and compares.
 
289
  TypeInfo UnaryType(UnaryOperation* expr);
 
290
  TypeInfo BinaryType(BinaryOperation* expr);
 
291
  TypeInfo CompareType(CompareOperation* expr);
 
292
  bool IsSymbolCompare(CompareOperation* expr);
 
293
  Handle<Map> GetCompareMap(CompareOperation* expr);
 
294
  TypeInfo SwitchType(CaseClause* clause);
 
295
  TypeInfo IncrementType(CountOperation* expr);
 
296
 
 
297
  Zone* zone() const { return zone_; }
 
298
 
 
299
 private:
 
300
  void CollectReceiverTypes(unsigned ast_id,
 
301
                            Handle<String> name,
 
302
                            Code::Flags flags,
 
303
                            SmallMapList* types);
 
304
 
 
305
  void SetInfo(unsigned ast_id, Object* target);
 
306
 
 
307
  void BuildDictionary(Handle<Code> code);
 
308
  void GetRelocInfos(Handle<Code> code, ZoneList<RelocInfo>* infos);
 
309
  void CreateDictionary(Handle<Code> code, ZoneList<RelocInfo>* infos);
 
310
  void RelocateRelocInfos(ZoneList<RelocInfo>* infos,
 
311
                          byte* old_start,
 
312
                          byte* new_start);
 
313
  void ProcessRelocInfos(ZoneList<RelocInfo>* infos);
 
314
  void ProcessTypeFeedbackCells(Handle<Code> code);
 
315
 
 
316
  // Returns an element from the backing store. Returns undefined if
 
317
  // there is no information.
 
318
  Handle<Object> GetInfo(unsigned ast_id);
 
319
 
 
320
  Handle<Context> global_context_;
 
321
  Isolate* isolate_;
 
322
  Handle<UnseededNumberDictionary> dictionary_;
 
323
  Zone* zone_;
 
324
 
 
325
  DISALLOW_COPY_AND_ASSIGN(TypeFeedbackOracle);
 
326
};
 
327
 
 
328
} }  // namespace v8::internal
 
329
 
 
330
#endif  // V8_TYPE_INFO_H_