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 class V8_EXPORT_PRIVATE CodeFactory final {
     32  public:
     33   // Initial states for ICs.
     34   static Callable LoadIC(Isolate* isolate);
     35   static Callable LoadICInOptimizedCode(Isolate* isolate);
     36   static Callable LoadGlobalIC(Isolate* isolate, TypeofMode typeof_mode);
     37   static Callable LoadGlobalICInOptimizedCode(Isolate* isolate,
     38                                               TypeofMode typeof_mode);
     39   static Callable KeyedLoadIC(Isolate* isolate);
     40   static Callable KeyedLoadICInOptimizedCode(Isolate* isolate);
     41   static Callable KeyedLoadIC_Megamorphic(Isolate* isolate);
     42   static Callable CallIC(Isolate* isolate,
     43                          ConvertReceiverMode mode = ConvertReceiverMode::kAny,
     44                          TailCallMode tail_call_mode = TailCallMode::kDisallow);
     45   static Callable CallICInOptimizedCode(
     46       Isolate* isolate, ConvertReceiverMode mode = ConvertReceiverMode::kAny,
     47       TailCallMode tail_call_mode = TailCallMode::kDisallow);
     48   static Callable StoreIC(Isolate* isolate, LanguageMode mode);
     49   static Callable StoreICInOptimizedCode(Isolate* isolate, LanguageMode mode);
     50   static Callable KeyedStoreIC(Isolate* isolate, LanguageMode mode);
     51   static Callable KeyedStoreICInOptimizedCode(Isolate* isolate,
     52                                               LanguageMode mode);
     53   static Callable KeyedStoreIC_Megamorphic(Isolate* isolate, 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   static Callable OrdinaryHasInstance(Isolate* isolate);
     68 
     69   static Callable StringFromCharCode(Isolate* isolate);
     70 
     71   static Callable GetProperty(Isolate* isolate);
     72 
     73   static Callable ToBoolean(Isolate* isolate);
     74 
     75   static Callable ToNumber(Isolate* isolate);
     76   static Callable NonNumberToNumber(Isolate* isolate);
     77   static Callable StringToNumber(Isolate* isolate);
     78   static Callable ToString(Isolate* isolate);
     79   static Callable ToName(Isolate* isolate);
     80   static Callable ToInteger(Isolate* isolate);
     81   static Callable ToLength(Isolate* isolate);
     82   static Callable ToObject(Isolate* isolate);
     83   static Callable NonPrimitiveToPrimitive(
     84       Isolate* isolate, ToPrimitiveHint hint = ToPrimitiveHint::kDefault);
     85   static Callable OrdinaryToPrimitive(Isolate* isolate,
     86                                       OrdinaryToPrimitiveHint hint);
     87   static Callable NumberToString(Isolate* isolate);
     88 
     89   static Callable RegExpExec(Isolate* isolate);
     90 
     91   static Callable Add(Isolate* isolate);
     92   static Callable Subtract(Isolate* isolate);
     93   static Callable Multiply(Isolate* isolate);
     94   static Callable Divide(Isolate* isolate);
     95   static Callable Modulus(Isolate* isolate);
     96   static Callable ShiftRight(Isolate* isolate);
     97   static Callable ShiftRightLogical(Isolate* isolate);
     98   static Callable ShiftLeft(Isolate* isolate);
     99   static Callable BitwiseAnd(Isolate* isolate);
    100   static Callable BitwiseOr(Isolate* isolate);
    101   static Callable BitwiseXor(Isolate* isolate);
    102   static Callable Inc(Isolate* isolate);
    103   static Callable Dec(Isolate* isolate);
    104   static Callable LessThan(Isolate* isolate);
    105   static Callable LessThanOrEqual(Isolate* isolate);
    106   static Callable GreaterThan(Isolate* isolate);
    107   static Callable GreaterThanOrEqual(Isolate* isolate);
    108   static Callable Equal(Isolate* isolate);
    109   static Callable NotEqual(Isolate* isolate);
    110   static Callable StrictEqual(Isolate* isolate);
    111   static Callable StrictNotEqual(Isolate* isolate);
    112 
    113   static Callable StringAdd(Isolate* isolate, StringAddFlags flags,
    114                             PretenureFlag pretenure_flag);
    115   static Callable StringCompare(Isolate* isolate, Token::Value token);
    116   static Callable StringEqual(Isolate* isolate);
    117   static Callable StringNotEqual(Isolate* isolate);
    118   static Callable StringLessThan(Isolate* isolate);
    119   static Callable StringLessThanOrEqual(Isolate* isolate);
    120   static Callable StringGreaterThan(Isolate* isolate);
    121   static Callable StringGreaterThanOrEqual(Isolate* isolate);
    122   static Callable SubString(Isolate* isolate);
    123 
    124   static Callable Typeof(Isolate* isolate);
    125 
    126   static Callable FastCloneRegExp(Isolate* isolate);
    127   static Callable FastCloneShallowArray(Isolate* isolate);
    128   static Callable FastCloneShallowObject(Isolate* isolate, int length);
    129 
    130   static Callable FastNewFunctionContext(Isolate* isolate);
    131   static Callable FastNewClosure(Isolate* isolate);
    132   static Callable FastNewObject(Isolate* isolate);
    133   static Callable FastNewRestParameter(Isolate* isolate,
    134                                        bool skip_stub_frame = false);
    135   static Callable FastNewSloppyArguments(Isolate* isolate,
    136                                          bool skip_stub_frame = false);
    137   static Callable FastNewStrictArguments(Isolate* isolate,
    138                                          bool skip_stub_frame = false);
    139 
    140   static Callable CopyFastSmiOrObjectElements(Isolate* isolate);
    141   static Callable GrowFastDoubleElements(Isolate* isolate);
    142   static Callable GrowFastSmiOrObjectElements(Isolate* isolate);
    143 
    144   static Callable AllocateHeapNumber(Isolate* isolate);
    145 #define SIMD128_ALLOC(TYPE, Type, type, lane_count, lane_type) \
    146   static Callable Allocate##Type(Isolate* isolate);
    147   SIMD128_TYPES(SIMD128_ALLOC)
    148 #undef SIMD128_ALLOC
    149 
    150   static Callable ArgumentAdaptor(Isolate* isolate);
    151   static Callable Call(Isolate* isolate,
    152                        ConvertReceiverMode mode = ConvertReceiverMode::kAny,
    153                        TailCallMode tail_call_mode = TailCallMode::kDisallow);
    154   static Callable CallFunction(
    155       Isolate* isolate, ConvertReceiverMode mode = ConvertReceiverMode::kAny);
    156   static Callable Construct(Isolate* isolate);
    157   static Callable ConstructFunction(Isolate* isolate);
    158   static Callable HasProperty(Isolate* isolate);
    159   static Callable ForInFilter(Isolate* isolate);
    160 
    161   static Callable InterpreterPushArgsAndCall(
    162       Isolate* isolate, TailCallMode tail_call_mode,
    163       CallableType function_type = CallableType::kAny);
    164   static Callable InterpreterPushArgsAndConstruct(
    165       Isolate* isolate, CallableType function_type = CallableType::kAny);
    166   static Callable InterpreterPushArgsAndConstructArray(Isolate* isolate);
    167   static Callable InterpreterCEntry(Isolate* isolate, int result_size = 1);
    168   static Callable InterpreterOnStackReplacement(Isolate* isolate);
    169 };
    170 
    171 }  // namespace internal
    172 }  // namespace v8
    173 
    174 #endif  // V8_CODE_FACTORY_H_
    175