Home | History | Annotate | Download | only in src 
      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_CODE_FACTORY_H_
      6 #define V8_CODE_FACTORY_H_
      7 
      8 #include "src/allocation.h"
      9 #include "src/assembler.h"
     10 #include "src/codegen.h"
     11 #include "src/globals.h"
     12 #include "src/interface-descriptors.h"
     13 
     14 namespace v8 {
     15 namespace internal {
     16 
     17 // Associates a body of code with an interface descriptor.
     18 class Callable final BASE_EMBEDDED {
     19  public:
     20   Callable(Handle<Code> code, CallInterfaceDescriptor descriptor)
     21       : code_(code), descriptor_(descriptor) {}
     22 
     23   Handle<Code> code() const { return code_; }
     24   CallInterfaceDescriptor descriptor() const { return descriptor_; }
     25 
     26  private:
     27   const Handle<Code> code_;
     28   const CallInterfaceDescriptor descriptor_;
     29 };
     30 
     31 
     32 class CodeFactory final {
     33  public:
     34   // Initial states for ICs.
     35   static Callable LoadIC(Isolate* isolate);
     36   static Callable LoadICInOptimizedCode(Isolate* isolate);
     37   static Callable LoadGlobalIC(Isolate* isolate, TypeofMode typeof_mode);
     38   static Callable LoadGlobalICInOptimizedCode(Isolate* isolate,
     39                                               TypeofMode typeof_mode);
     40   static Callable KeyedLoadIC(Isolate* isolate);
     41   static Callable KeyedLoadICInOptimizedCode(Isolate* isolate);
     42   static Callable CallIC(Isolate* isolate, int argc,
     43                          ConvertReceiverMode mode = ConvertReceiverMode::kAny,
     44                          TailCallMode tail_call_mode = TailCallMode::kDisallow);
     45   static Callable CallICInOptimizedCode(
     46       Isolate* isolate, int argc,
     47       ConvertReceiverMode mode = ConvertReceiverMode::kAny,
     48       TailCallMode tail_call_mode = TailCallMode::kDisallow);
     49   static Callable StoreIC(Isolate* isolate, LanguageMode mode);
     50   static Callable StoreICInOptimizedCode(Isolate* isolate, LanguageMode mode);
     51   static Callable KeyedStoreIC(Isolate* isolate, LanguageMode mode);
     52   static Callable KeyedStoreICInOptimizedCode(Isolate* isolate,
     53                                               LanguageMode mode);
     54 
     55   static Callable ResumeGenerator(Isolate* isolate);
     56 
     57   static Callable CompareIC(Isolate* isolate, Token::Value op);
     58   static Callable CompareNilIC(Isolate* isolate, NilValue nil_value);
     59 
     60   static Callable BinaryOpIC(Isolate* isolate, Token::Value op);
     61 
     62   static Callable ApiGetter(Isolate* isolate);
     63 
     64   // Code stubs. Add methods here as needed to reduce dependency on
     65   // code-stubs.h.
     66   static Callable InstanceOf(Isolate* isolate);
     67 
     68   static Callable ToBoolean(Isolate* isolate);
     69 
     70   static Callable ToNumber(Isolate* isolate);
     71   static Callable NonNumberToNumber(Isolate* isolate);
     72   static Callable StringToNumber(Isolate* isolate);
     73   static Callable ToString(Isolate* isolate);
     74   static Callable ToName(Isolate* isolate);
     75   static Callable ToInteger(Isolate* isolate);
     76   static Callable ToLength(Isolate* isolate);
     77   static Callable ToObject(Isolate* isolate);
     78   static Callable NumberToString(Isolate* isolate);
     79 
     80   static Callable RegExpConstructResult(Isolate* isolate);
     81   static Callable RegExpExec(Isolate* isolate);
     82 
     83   static Callable Add(Isolate* isolate);
     84   static Callable Subtract(Isolate* isolate);
     85   static Callable Multiply(Isolate* isolate);
     86   static Callable Divide(Isolate* isolate);
     87   static Callable Modulus(Isolate* isolate);
     88   static Callable ShiftRight(Isolate* isolate);
     89   static Callable ShiftRightLogical(Isolate* isolate);
     90   static Callable ShiftLeft(Isolate* isolate);
     91   static Callable BitwiseAnd(Isolate* isolate);
     92   static Callable BitwiseOr(Isolate* isolate);
     93   static Callable BitwiseXor(Isolate* isolate);
     94   static Callable Inc(Isolate* isolate);
     95   static Callable Dec(Isolate* isolate);
     96   static Callable LessThan(Isolate* isolate);
     97   static Callable LessThanOrEqual(Isolate* isolate);
     98   static Callable GreaterThan(Isolate* isolate);
     99   static Callable GreaterThanOrEqual(Isolate* isolate);
    100   static Callable Equal(Isolate* isolate);
    101   static Callable NotEqual(Isolate* isolate);
    102   static Callable StrictEqual(Isolate* isolate);
    103   static Callable StrictNotEqual(Isolate* isolate);
    104 
    105   static Callable StringAdd(Isolate* isolate, StringAddFlags flags,
    106                             PretenureFlag pretenure_flag);
    107   static Callable StringCompare(Isolate* isolate, Token::Value token);
    108   static Callable StringEqual(Isolate* isolate);
    109   static Callable StringNotEqual(Isolate* isolate);
    110   static Callable StringLessThan(Isolate* isolate);
    111   static Callable StringLessThanOrEqual(Isolate* isolate);
    112   static Callable StringGreaterThan(Isolate* isolate);
    113   static Callable StringGreaterThanOrEqual(Isolate* isolate);
    114   static Callable SubString(Isolate* isolate);
    115 
    116   static Callable Typeof(Isolate* isolate);
    117 
    118   static Callable FastCloneRegExp(Isolate* isolate);
    119   static Callable FastCloneShallowArray(Isolate* isolate);
    120   static Callable FastCloneShallowObject(Isolate* isolate, int length);
    121 
    122   static Callable FastNewContext(Isolate* isolate, int slot_count);
    123   static Callable FastNewClosure(Isolate* isolate, LanguageMode language_mode,
    124                                  FunctionKind kind);
    125   static Callable FastNewObject(Isolate* isolate);
    126   static Callable FastNewRestParameter(Isolate* isolate,
    127                                        bool skip_stub_frame = false);
    128   static Callable FastNewSloppyArguments(Isolate* isolate,
    129                                          bool skip_stub_frame = false);
    130   static Callable FastNewStrictArguments(Isolate* isolate,
    131                                          bool skip_stub_frame = false);
    132 
    133   static Callable AllocateHeapNumber(Isolate* isolate);
    134 #define SIMD128_ALLOC(TYPE, Type, type, lane_count, lane_type) \
    135   static Callable Allocate##Type(Isolate* isolate);
    136   SIMD128_TYPES(SIMD128_ALLOC)
    137 #undef SIMD128_ALLOC
    138 
    139   static Callable ArgumentAdaptor(Isolate* isolate);
    140   static Callable Call(Isolate* isolate,
    141                        ConvertReceiverMode mode = ConvertReceiverMode::kAny,
    142                        TailCallMode tail_call_mode = TailCallMode::kDisallow);
    143   static Callable CallFunction(
    144       Isolate* isolate, ConvertReceiverMode mode = ConvertReceiverMode::kAny);
    145   static Callable Construct(Isolate* isolate);
    146   static Callable ConstructFunction(Isolate* isolate);
    147   static Callable HasProperty(Isolate* isolate);
    148 
    149   static Callable MathPow(Isolate* isolate);
    150 
    151   static Callable InterpreterPushArgsAndCall(Isolate* isolate,
    152                                              TailCallMode tail_call_mode);
    153   static Callable InterpreterPushArgsAndConstruct(Isolate* isolate);
    154   static Callable InterpreterCEntry(Isolate* isolate, int result_size = 1);
    155 };
    156 
    157 }  // namespace internal
    158 }  // namespace v8
    159 
    160 #endif  // V8_CODE_FACTORY_H_
    161