Line data Source code
1 : // Copyright 2014 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_COMPILER_SIMPLIFIED_OPERATOR_H_
6 : #define V8_COMPILER_SIMPLIFIED_OPERATOR_H_
7 :
8 : #include <iosfwd>
9 :
10 : #include "src/base/compiler-specific.h"
11 : #include "src/compiler/operator.h"
12 : #include "src/compiler/types.h"
13 : #include "src/deoptimize-reason.h"
14 : #include "src/globals.h"
15 : #include "src/handles.h"
16 : #include "src/machine-type.h"
17 : #include "src/objects.h"
18 : #include "src/type-hints.h"
19 : #include "src/zone/zone-handle-set.h"
20 :
21 : namespace v8 {
22 : namespace internal {
23 :
24 : // Forward declarations.
25 : class Zone;
26 :
27 : namespace compiler {
28 :
29 : // Forward declarations.
30 : class Operator;
31 : struct SimplifiedOperatorGlobalCache;
32 :
33 : enum BaseTaggedness : uint8_t { kUntaggedBase, kTaggedBase };
34 :
35 : size_t hash_value(BaseTaggedness);
36 :
37 : std::ostream& operator<<(std::ostream&, BaseTaggedness);
38 :
39 : // An access descriptor for loads/stores of fixed structures like field
40 : // accesses of heap objects. Accesses from either tagged or untagged base
41 : // pointers are supported; untagging is done automatically during lowering.
42 7019 : struct FieldAccess {
43 : BaseTaggedness base_is_tagged; // specifies if the base pointer is tagged.
44 : int offset; // offset of the field, without tag.
45 : MaybeHandle<Name> name; // debugging only.
46 : MaybeHandle<Map> map; // map of the field value (if known).
47 : Type* type; // type of the field.
48 : MachineType machine_type; // machine type of the field.
49 : WriteBarrierKind write_barrier_kind; // write barrier hint.
50 :
51 9252913 : int tag() const { return base_is_tagged == kTaggedBase ? kHeapObjectTag : 0; }
52 : };
53 :
54 : V8_EXPORT_PRIVATE bool operator==(FieldAccess const&, FieldAccess const&);
55 :
56 : size_t hash_value(FieldAccess const&);
57 :
58 : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, FieldAccess const&);
59 :
60 : FieldAccess const& FieldAccessOf(const Operator* op) WARN_UNUSED_RESULT;
61 :
62 : template <>
63 : void Operator1<FieldAccess>::PrintParameter(std::ostream& os,
64 : PrintVerbosity verbose) const;
65 :
66 : // An access descriptor for loads/stores of indexed structures like characters
67 : // in strings or off-heap backing stores. Accesses from either tagged or
68 : // untagged base pointers are supported; untagging is done automatically during
69 : // lowering.
70 3082 : struct ElementAccess {
71 : BaseTaggedness base_is_tagged; // specifies if the base pointer is tagged.
72 : int header_size; // size of the header, without tag.
73 : Type* type; // type of the element.
74 : MachineType machine_type; // machine type of the element.
75 : WriteBarrierKind write_barrier_kind; // write barrier hint.
76 :
77 277122 : int tag() const { return base_is_tagged == kTaggedBase ? kHeapObjectTag : 0; }
78 : };
79 :
80 : V8_EXPORT_PRIVATE bool operator==(ElementAccess const&, ElementAccess const&);
81 :
82 : size_t hash_value(ElementAccess const&);
83 :
84 : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, ElementAccess const&);
85 :
86 : V8_EXPORT_PRIVATE ElementAccess const& ElementAccessOf(const Operator* op)
87 : WARN_UNUSED_RESULT;
88 :
89 : ExternalArrayType ExternalArrayTypeOf(const Operator* op) WARN_UNUSED_RESULT;
90 :
91 : enum class CheckFloat64HoleMode : uint8_t {
92 : kNeverReturnHole, // Never return the hole (deoptimize instead).
93 : kAllowReturnHole // Allow to return the hole (signaling NaN).
94 : };
95 :
96 : size_t hash_value(CheckFloat64HoleMode);
97 :
98 : std::ostream& operator<<(std::ostream&, CheckFloat64HoleMode);
99 :
100 : CheckFloat64HoleMode CheckFloat64HoleModeOf(const Operator*) WARN_UNUSED_RESULT;
101 :
102 : enum class CheckTaggedInputMode : uint8_t {
103 : kNumber,
104 : kNumberOrOddball,
105 : };
106 :
107 : size_t hash_value(CheckTaggedInputMode);
108 :
109 : std::ostream& operator<<(std::ostream&, CheckTaggedInputMode);
110 :
111 : CheckTaggedInputMode CheckTaggedInputModeOf(const Operator*) WARN_UNUSED_RESULT;
112 :
113 : enum class CheckForMinusZeroMode : uint8_t {
114 : kCheckForMinusZero,
115 : kDontCheckForMinusZero,
116 : };
117 :
118 : size_t hash_value(CheckForMinusZeroMode);
119 :
120 : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&,
121 : CheckForMinusZeroMode);
122 :
123 : CheckForMinusZeroMode CheckMinusZeroModeOf(const Operator*) WARN_UNUSED_RESULT;
124 :
125 : // Flags for map checks.
126 : enum class CheckMapsFlag : uint8_t {
127 : kNone = 0u,
128 : kTryMigrateInstance = 1u << 0, // Try instance migration.
129 : };
130 : typedef base::Flags<CheckMapsFlag> CheckMapsFlags;
131 :
132 : DEFINE_OPERATORS_FOR_FLAGS(CheckMapsFlags)
133 :
134 : std::ostream& operator<<(std::ostream&, CheckMapsFlags);
135 :
136 : class MapsParameterInfo {
137 : public:
138 : explicit MapsParameterInfo(ZoneHandleSet<Map> const& maps);
139 :
140 : Maybe<InstanceType> instance_type() const { return instance_type_; }
141 : ZoneHandleSet<Map> const& maps() const { return maps_; }
142 :
143 : private:
144 : ZoneHandleSet<Map> const maps_;
145 : Maybe<InstanceType> instance_type_;
146 : };
147 :
148 : std::ostream& operator<<(std::ostream&, MapsParameterInfo const&);
149 :
150 : bool operator==(MapsParameterInfo const&, MapsParameterInfo const&);
151 : bool operator!=(MapsParameterInfo const&, MapsParameterInfo const&);
152 :
153 : size_t hash_value(MapsParameterInfo const&);
154 :
155 : // A descriptor for map checks.
156 : class CheckMapsParameters final {
157 : public:
158 : CheckMapsParameters(CheckMapsFlags flags, ZoneHandleSet<Map> const& maps)
159 84532 : : flags_(flags), maps_info_(maps) {}
160 :
161 : CheckMapsFlags flags() const { return flags_; }
162 : ZoneHandleSet<Map> const& maps() const { return maps_info_.maps(); }
163 : MapsParameterInfo const& maps_info() const { return maps_info_; }
164 :
165 : private:
166 : CheckMapsFlags const flags_;
167 : MapsParameterInfo const maps_info_;
168 : };
169 :
170 : bool operator==(CheckMapsParameters const&, CheckMapsParameters const&);
171 :
172 : size_t hash_value(CheckMapsParameters const&);
173 :
174 : std::ostream& operator<<(std::ostream&, CheckMapsParameters const&);
175 :
176 : CheckMapsParameters const& CheckMapsParametersOf(Operator const*)
177 : WARN_UNUSED_RESULT;
178 :
179 : MapsParameterInfo const& MapGuardMapsOf(Operator const*) WARN_UNUSED_RESULT;
180 :
181 : // Parameters for CompareMaps operator.
182 : MapsParameterInfo const& CompareMapsParametersOf(Operator const*)
183 : WARN_UNUSED_RESULT;
184 :
185 : // A descriptor for growing elements backing stores.
186 : enum class GrowFastElementsMode : uint8_t {
187 : kDoubleElements,
188 : kSmiOrObjectElements
189 : };
190 :
191 0 : inline size_t hash_value(GrowFastElementsMode mode) {
192 0 : return static_cast<uint8_t>(mode);
193 : }
194 :
195 : std::ostream& operator<<(std::ostream&, GrowFastElementsMode);
196 :
197 : GrowFastElementsMode GrowFastElementsModeOf(const Operator*) WARN_UNUSED_RESULT;
198 :
199 : // The ToBooleanHints are used as parameter by ToBoolean operators.
200 : ToBooleanHints ToBooleanHintsOf(Operator const* op);
201 :
202 : // A descriptor for elements kind transitions.
203 : class ElementsTransition final {
204 : public:
205 : enum Mode : uint8_t {
206 : kFastTransition, // simple transition, just updating the map.
207 : kSlowTransition // full transition, round-trip to the runtime.
208 : };
209 :
210 : ElementsTransition(Mode mode, Handle<Map> source, Handle<Map> target)
211 619 : : mode_(mode), source_(source), target_(target) {}
212 :
213 : Mode mode() const { return mode_; }
214 : Handle<Map> source() const { return source_; }
215 : Handle<Map> target() const { return target_; }
216 :
217 : private:
218 : Mode const mode_;
219 : Handle<Map> const source_;
220 : Handle<Map> const target_;
221 : };
222 :
223 : bool operator==(ElementsTransition const&, ElementsTransition const&);
224 :
225 : size_t hash_value(ElementsTransition);
226 :
227 : std::ostream& operator<<(std::ostream&, ElementsTransition);
228 :
229 : ElementsTransition const& ElementsTransitionOf(const Operator* op)
230 : WARN_UNUSED_RESULT;
231 :
232 : // Parameters for TransitionAndStoreElement, or
233 : // TransitionAndStoreNonNumberElement, or
234 : // TransitionAndStoreNumberElement.
235 : Handle<Map> DoubleMapParameterOf(const Operator* op);
236 : Handle<Map> FastMapParameterOf(const Operator* op);
237 :
238 : // Parameters for TransitionAndStoreNonNumberElement.
239 : Type* ValueTypeParameterOf(const Operator* op);
240 :
241 : // A hint for speculative number operations.
242 : enum class NumberOperationHint : uint8_t {
243 : kSignedSmall, // Inputs were Smi, output was in Smi.
244 : kSignedSmallInputs, // Inputs were Smi, output was Number.
245 : kSigned32, // Inputs were Signed32, output was Number.
246 : kNumber, // Inputs were Number, output was Number.
247 : kNumberOrOddball, // Inputs were Number or Oddball, output was Number.
248 : };
249 :
250 : size_t hash_value(NumberOperationHint);
251 :
252 : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, NumberOperationHint);
253 :
254 : NumberOperationHint NumberOperationHintOf(const Operator* op)
255 : WARN_UNUSED_RESULT;
256 :
257 : int FormalParameterCountOf(const Operator* op) WARN_UNUSED_RESULT;
258 : bool IsRestLengthOf(const Operator* op) WARN_UNUSED_RESULT;
259 :
260 : class AllocateParameters {
261 : public:
262 : AllocateParameters(Type* type, PretenureFlag pretenure)
263 : : type_(type), pretenure_(pretenure) {}
264 :
265 : Type* type() const { return type_; }
266 : PretenureFlag pretenure() const { return pretenure_; }
267 :
268 : private:
269 : Type* type_;
270 : PretenureFlag pretenure_;
271 : };
272 :
273 : size_t hash_value(AllocateParameters);
274 :
275 : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, AllocateParameters);
276 :
277 : bool operator==(AllocateParameters const&, AllocateParameters const&);
278 :
279 : PretenureFlag PretenureFlagOf(const Operator* op) WARN_UNUSED_RESULT;
280 :
281 : Type* AllocateTypeOf(const Operator* op) WARN_UNUSED_RESULT;
282 :
283 : UnicodeEncoding UnicodeEncodingOf(const Operator*) WARN_UNUSED_RESULT;
284 :
285 : BailoutReason BailoutReasonOf(const Operator* op) WARN_UNUSED_RESULT;
286 :
287 : DeoptimizeReason DeoptimizeReasonOf(const Operator* op) WARN_UNUSED_RESULT;
288 :
289 : // Interface for building simplified operators, which represent the
290 : // medium-level operations of V8, including adding numbers, allocating objects,
291 : // indexing into objects and arrays, etc.
292 : // All operators are typed but many are representation independent.
293 :
294 : // Number values from JS can be in one of these representations:
295 : // - Tagged: word-sized integer that is either
296 : // - a signed small integer (31 or 32 bits plus a tag)
297 : // - a tagged pointer to a HeapNumber object that has a float64 field
298 : // - Int32: an untagged signed 32-bit integer
299 : // - Uint32: an untagged unsigned 32-bit integer
300 : // - Float64: an untagged float64
301 :
302 : // Additional representations for intermediate code or non-JS code:
303 : // - Int64: an untagged signed 64-bit integer
304 : // - Uint64: an untagged unsigned 64-bit integer
305 : // - Float32: an untagged float32
306 :
307 : // Boolean values can be:
308 : // - Bool: a tagged pointer to either the canonical JS #false or
309 : // the canonical JS #true object
310 : // - Bit: an untagged integer 0 or 1, but word-sized
311 : class V8_EXPORT_PRIVATE SimplifiedOperatorBuilder final
312 : : public NON_EXPORTED_BASE(ZoneObject) {
313 : public:
314 : explicit SimplifiedOperatorBuilder(Zone* zone);
315 :
316 : const Operator* BooleanNot();
317 :
318 : const Operator* NumberEqual();
319 : const Operator* NumberLessThan();
320 : const Operator* NumberLessThanOrEqual();
321 : const Operator* NumberAdd();
322 : const Operator* NumberSubtract();
323 : const Operator* NumberMultiply();
324 : const Operator* NumberDivide();
325 : const Operator* NumberModulus();
326 : const Operator* NumberBitwiseOr();
327 : const Operator* NumberBitwiseXor();
328 : const Operator* NumberBitwiseAnd();
329 : const Operator* NumberShiftLeft();
330 : const Operator* NumberShiftRight();
331 : const Operator* NumberShiftRightLogical();
332 : const Operator* NumberImul();
333 : const Operator* NumberAbs();
334 : const Operator* NumberClz32();
335 : const Operator* NumberCeil();
336 : const Operator* NumberFloor();
337 : const Operator* NumberFround();
338 : const Operator* NumberAcos();
339 : const Operator* NumberAcosh();
340 : const Operator* NumberAsin();
341 : const Operator* NumberAsinh();
342 : const Operator* NumberAtan();
343 : const Operator* NumberAtan2();
344 : const Operator* NumberAtanh();
345 : const Operator* NumberCbrt();
346 : const Operator* NumberCos();
347 : const Operator* NumberCosh();
348 : const Operator* NumberExp();
349 : const Operator* NumberExpm1();
350 : const Operator* NumberLog();
351 : const Operator* NumberLog1p();
352 : const Operator* NumberLog10();
353 : const Operator* NumberLog2();
354 : const Operator* NumberMax();
355 : const Operator* NumberMin();
356 : const Operator* NumberPow();
357 : const Operator* NumberRound();
358 : const Operator* NumberSign();
359 : const Operator* NumberSin();
360 : const Operator* NumberSinh();
361 : const Operator* NumberSqrt();
362 : const Operator* NumberTan();
363 : const Operator* NumberTanh();
364 : const Operator* NumberTrunc();
365 : const Operator* NumberToBoolean();
366 : const Operator* NumberToInt32();
367 : const Operator* NumberToUint32();
368 : const Operator* NumberToUint8Clamped();
369 :
370 : const Operator* NumberSilenceNaN();
371 :
372 : const Operator* SpeculativeSafeIntegerAdd(NumberOperationHint hint);
373 : const Operator* SpeculativeSafeIntegerSubtract(NumberOperationHint hint);
374 :
375 : const Operator* SpeculativeNumberAdd(NumberOperationHint hint);
376 : const Operator* SpeculativeNumberSubtract(NumberOperationHint hint);
377 : const Operator* SpeculativeNumberMultiply(NumberOperationHint hint);
378 : const Operator* SpeculativeNumberDivide(NumberOperationHint hint);
379 : const Operator* SpeculativeNumberModulus(NumberOperationHint hint);
380 : const Operator* SpeculativeNumberShiftLeft(NumberOperationHint hint);
381 : const Operator* SpeculativeNumberShiftRight(NumberOperationHint hint);
382 : const Operator* SpeculativeNumberShiftRightLogical(NumberOperationHint hint);
383 : const Operator* SpeculativeNumberBitwiseAnd(NumberOperationHint hint);
384 : const Operator* SpeculativeNumberBitwiseOr(NumberOperationHint hint);
385 : const Operator* SpeculativeNumberBitwiseXor(NumberOperationHint hint);
386 :
387 : const Operator* SpeculativeNumberLessThan(NumberOperationHint hint);
388 : const Operator* SpeculativeNumberLessThanOrEqual(NumberOperationHint hint);
389 : const Operator* SpeculativeNumberEqual(NumberOperationHint hint);
390 :
391 : const Operator* ReferenceEqual();
392 :
393 : const Operator* TypeOf();
394 : const Operator* ClassOf();
395 :
396 : const Operator* ToBoolean(ToBooleanHints hints);
397 :
398 : const Operator* StringEqual();
399 : const Operator* StringLessThan();
400 : const Operator* StringLessThanOrEqual();
401 : const Operator* StringCharAt();
402 : const Operator* StringCharCodeAt();
403 : const Operator* SeqStringCharCodeAt();
404 : const Operator* StringFromCharCode();
405 : const Operator* StringFromCodePoint(UnicodeEncoding encoding);
406 : const Operator* StringIndexOf();
407 : const Operator* StringToLowerCaseIntl();
408 : const Operator* StringToUpperCaseIntl();
409 :
410 : const Operator* FindOrderedHashMapEntry();
411 : const Operator* FindOrderedHashMapEntryForInt32Key();
412 :
413 : const Operator* SpeculativeToNumber(NumberOperationHint hint);
414 :
415 : const Operator* StringToNumber();
416 : const Operator* PlainPrimitiveToNumber();
417 : const Operator* PlainPrimitiveToWord32();
418 : const Operator* PlainPrimitiveToFloat64();
419 :
420 : const Operator* ChangeTaggedSignedToInt32();
421 : const Operator* ChangeTaggedToInt32();
422 : const Operator* ChangeTaggedToUint32();
423 : const Operator* ChangeTaggedToFloat64();
424 : const Operator* ChangeTaggedToTaggedSigned();
425 : const Operator* ChangeInt31ToTaggedSigned();
426 : const Operator* ChangeInt32ToTagged();
427 : const Operator* ChangeUint32ToTagged();
428 : const Operator* ChangeFloat64ToTagged(CheckForMinusZeroMode);
429 : const Operator* ChangeFloat64ToTaggedPointer();
430 : const Operator* ChangeTaggedToBit();
431 : const Operator* ChangeBitToTagged();
432 : const Operator* TruncateTaggedToWord32();
433 : const Operator* TruncateTaggedToFloat64();
434 : const Operator* TruncateTaggedToBit();
435 : const Operator* TruncateTaggedPointerToBit();
436 :
437 : const Operator* CheckIf(DeoptimizeReason deoptimize_reason);
438 : const Operator* CheckBounds();
439 : const Operator* CheckMaps(CheckMapsFlags, ZoneHandleSet<Map>);
440 : const Operator* CompareMaps(ZoneHandleSet<Map>);
441 : const Operator* MapGuard(ZoneHandleSet<Map> maps);
442 :
443 : const Operator* CheckHeapObject();
444 : const Operator* CheckInternalizedString();
445 : const Operator* CheckNumber();
446 : const Operator* CheckSmi();
447 : const Operator* CheckString();
448 : const Operator* CheckSeqString();
449 : const Operator* CheckSymbol();
450 : const Operator* CheckReceiver();
451 :
452 : const Operator* CheckedInt32Add();
453 : const Operator* CheckedInt32Sub();
454 : const Operator* CheckedInt32Div();
455 : const Operator* CheckedInt32Mod();
456 : const Operator* CheckedUint32Div();
457 : const Operator* CheckedUint32Mod();
458 : const Operator* CheckedInt32Mul(CheckForMinusZeroMode);
459 : const Operator* CheckedInt32ToTaggedSigned();
460 : const Operator* CheckedUint32ToInt32();
461 : const Operator* CheckedUint32ToTaggedSigned();
462 : const Operator* CheckedFloat64ToInt32(CheckForMinusZeroMode);
463 : const Operator* CheckedTaggedSignedToInt32();
464 : const Operator* CheckedTaggedToInt32(CheckForMinusZeroMode);
465 : const Operator* CheckedTaggedToFloat64(CheckTaggedInputMode);
466 : const Operator* CheckedTaggedToTaggedSigned();
467 : const Operator* CheckedTaggedToTaggedPointer();
468 : const Operator* CheckedTruncateTaggedToWord32(CheckTaggedInputMode);
469 :
470 : const Operator* CheckFloat64Hole(CheckFloat64HoleMode);
471 : const Operator* CheckNotTaggedHole();
472 : const Operator* ConvertTaggedHoleToUndefined();
473 :
474 : const Operator* CheckEqualsInternalizedString();
475 : const Operator* CheckEqualsSymbol();
476 :
477 : const Operator* ObjectIsArrayBufferView();
478 : const Operator* ObjectIsCallable();
479 : const Operator* ObjectIsConstructor();
480 : const Operator* ObjectIsDetectableCallable();
481 : const Operator* ObjectIsMinusZero();
482 : const Operator* ObjectIsNaN();
483 : const Operator* ObjectIsNonCallable();
484 : const Operator* ObjectIsNumber();
485 : const Operator* ObjectIsReceiver();
486 : const Operator* ObjectIsSmi();
487 : const Operator* ObjectIsString();
488 : const Operator* ObjectIsSymbol();
489 : const Operator* ObjectIsUndetectable();
490 :
491 : const Operator* ArgumentsFrame();
492 : const Operator* ArgumentsLength(int formal_parameter_count,
493 : bool is_rest_length);
494 :
495 : const Operator* NewDoubleElements(PretenureFlag);
496 : const Operator* NewSmiOrObjectElements(PretenureFlag);
497 :
498 : // new-arguments-elements arguments-frame, arguments-length
499 : const Operator* NewArgumentsElements(int mapped_count);
500 :
501 : // array-buffer-was-neutered buffer
502 : const Operator* ArrayBufferWasNeutered();
503 :
504 : // ensure-writable-fast-elements object, elements
505 : const Operator* EnsureWritableFastElements();
506 :
507 : // maybe-grow-fast-elements object, elements, index, length
508 : const Operator* MaybeGrowFastElements(GrowFastElementsMode mode);
509 :
510 : // transition-elements-kind object, from-map, to-map
511 : const Operator* TransitionElementsKind(ElementsTransition transition);
512 :
513 : const Operator* Allocate(Type* type, PretenureFlag pretenure = NOT_TENURED);
514 :
515 : const Operator* LoadFieldByIndex();
516 : const Operator* LoadField(FieldAccess const&);
517 : const Operator* StoreField(FieldAccess const&);
518 :
519 : // load-element [base + index]
520 : const Operator* LoadElement(ElementAccess const&);
521 :
522 : // store-element [base + index], value
523 : const Operator* StoreElement(ElementAccess const&);
524 :
525 : // store-element [base + index], value, only with fast arrays.
526 : const Operator* TransitionAndStoreElement(Handle<Map> double_map,
527 : Handle<Map> fast_map);
528 : // store-element [base + index], smi value, only with fast arrays.
529 : const Operator* StoreSignedSmallElement();
530 :
531 : // store-element [base + index], double value, only with fast arrays.
532 : const Operator* TransitionAndStoreNumberElement(Handle<Map> double_map);
533 :
534 : // store-element [base + index], object value, only with fast arrays.
535 : const Operator* TransitionAndStoreNonNumberElement(Handle<Map> fast_map,
536 : Type* value_type);
537 :
538 : // load-typed-element buffer, [base + external + index]
539 : const Operator* LoadTypedElement(ExternalArrayType const&);
540 :
541 : // store-typed-element buffer, [base + external + index], value
542 : const Operator* StoreTypedElement(ExternalArrayType const&);
543 :
544 : // Abort (for terminating execution on internal error).
545 : const Operator* RuntimeAbort(BailoutReason reason);
546 :
547 : private:
548 : Zone* zone() const { return zone_; }
549 :
550 : const SimplifiedOperatorGlobalCache& cache_;
551 : Zone* const zone_;
552 :
553 : DISALLOW_COPY_AND_ASSIGN(SimplifiedOperatorBuilder);
554 : };
555 :
556 : } // namespace compiler
557 : } // namespace internal
558 : } // namespace v8
559 :
560 : #endif // V8_COMPILER_SIMPLIFIED_OPERATOR_H_
|
