diff options
Diffstat (limited to 'deps/v8/src/fast-accessor-assembler.h')
-rw-r--r-- | deps/v8/src/fast-accessor-assembler.h | 104 |
1 files changed, 104 insertions, 0 deletions
diff --git a/deps/v8/src/fast-accessor-assembler.h b/deps/v8/src/fast-accessor-assembler.h new file mode 100644 index 0000000000..57e72e8eb1 --- /dev/null +++ b/deps/v8/src/fast-accessor-assembler.h @@ -0,0 +1,104 @@ +// Copyright 2015 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef V8_FAST_ACCESSOR_ASSEMBLER_H_ +#define V8_FAST_ACCESSOR_ASSEMBLER_H_ + +#include <stdint.h> +#include <vector> + +#include "include/v8-experimental.h" +#include "src/base/macros.h" +#include "src/base/smart-pointers.h" +#include "src/handles.h" + +// For CodeStubAssembler::Label. (We cannot forward-declare inner classes.) +#include "src/compiler/code-stub-assembler.h" + +namespace v8 { +namespace internal { + +class Code; +class Isolate; +class Zone; + +namespace compiler { +class Node; +} + +// This interface "exports" an aggregated subset of RawMachineAssembler, for +// use by the API to implement Fast Dom Accessors. +// +// This interface is made for this single purpose only and does not attempt +// to implement a general purpose solution. If you need one, please look at +// RawMachineAssembler instead. +// +// The life cycle of a FastAccessorAssembler has two phases: +// - After creating the instance, you can call an arbitrary sequence of +// builder functions to build the desired function. +// - When done, you can Build() the accessor and query for the build results. +// +// You cannot call any result getters before Build() was called & successful; +// and you cannot call any builder functions after Build() was called. +class FastAccessorAssembler { + public: + typedef v8::experimental::FastAccessorBuilder::ValueId ValueId; + typedef v8::experimental::FastAccessorBuilder::LabelId LabelId; + typedef v8::FunctionCallback FunctionCallback; + + explicit FastAccessorAssembler(Isolate* isolate); + ~FastAccessorAssembler(); + + // Builder / assembler functions: + ValueId IntegerConstant(int int_constant); + ValueId GetReceiver(); + ValueId LoadInternalField(ValueId value_id, int field_no); + ValueId LoadValue(ValueId value_id, int offset); + ValueId LoadObject(ValueId value_id, int offset); + + // Builder / assembler functions for control flow. + void ReturnValue(ValueId value_id); + void CheckFlagSetOrReturnNull(ValueId value_id, int mask); + void CheckNotZeroOrReturnNull(ValueId value_id); + LabelId MakeLabel(); + void SetLabel(LabelId label_id); + void CheckNotZeroOrJump(ValueId value_id, LabelId label_id); + + // C++ callback. + ValueId Call(FunctionCallback callback, ValueId arg); + + // Assemble the code. + MaybeHandle<Code> Build(); + + private: + ValueId FromRaw(compiler::Node* node); + LabelId FromRaw(compiler::CodeStubAssembler::Label* label); + compiler::Node* FromId(ValueId value) const; + compiler::CodeStubAssembler::Label* FromId(LabelId value) const; + + void Clear(); + Zone* zone() { return &zone_; } + Isolate* isolate() const { return isolate_; } + + Zone zone_; + Isolate* isolate_; + base::SmartPointer<compiler::CodeStubAssembler> assembler_; + + // To prevent exposing the RMA internals to the outside world, we'll map + // Node + Label pointers integers wrapped in ValueId and LabelId instances. + // These vectors maintain this mapping. + std::vector<compiler::Node*> nodes_; + std::vector<compiler::CodeStubAssembler::Label*> labels_; + + // Remember the current state for easy error checking. (We prefer to be + // strict as this class will be exposed at the API.) + enum { kBuilding, kBuilt, kError } state_; + + DISALLOW_COPY_AND_ASSIGN(FastAccessorAssembler); +}; + +} // namespace internal +} // namespace v8 + +#endif // V8_FAST_ACCESSOR_ASSEMBLER_H_ |