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_CODEGEN_H_
6 #define V8_CODEGEN_H_
7 
8 #include "src/code-stubs.h"
9 #include "src/runtime.h"
10 
11 // Include the declaration of the architecture defined class CodeGenerator.
12 // The contract  to the shared code is that the the CodeGenerator is a subclass
13 // of Visitor and that the following methods are available publicly:
14 //   MakeCode
15 //   MakeCodePrologue
16 //   MakeCodeEpilogue
17 //   masm
18 //   frame
19 //   script
20 //   has_valid_frame
21 //   SetFrame
22 //   DeleteFrame
23 //   allocator
24 //   AddDeferred
25 //   in_spilled_code
26 //   set_in_spilled_code
27 //   RecordPositions
28 //
29 // These methods are either used privately by the shared code or implemented as
30 // shared code:
31 //   CodeGenerator
32 //   ~CodeGenerator
33 //   Generate
34 //   ComputeLazyCompile
35 //   BuildFunctionInfo
36 //   ProcessDeclarations
37 //   DeclareGlobals
38 //   CheckForInlineRuntimeCall
39 //   AnalyzeCondition
40 //   CodeForFunctionPosition
41 //   CodeForReturnPosition
42 //   CodeForStatementPosition
43 //   CodeForDoWhileConditionPosition
44 //   CodeForSourcePosition
45 
46 enum TypeofState { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF };
47 
48 #if V8_TARGET_ARCH_IA32
49 #include "src/ia32/codegen-ia32.h"  // NOLINT
50 #elif V8_TARGET_ARCH_X64
51 #include "src/x64/codegen-x64.h"  // NOLINT
52 #elif V8_TARGET_ARCH_ARM64
53 #include "src/arm64/codegen-arm64.h"  // NOLINT
54 #elif V8_TARGET_ARCH_ARM
55 #include "src/arm/codegen-arm.h"  // NOLINT
56 #elif V8_TARGET_ARCH_MIPS
57 #include "src/mips/codegen-mips.h"  // NOLINT
58 #elif V8_TARGET_ARCH_MIPS64
59 #include "src/mips64/codegen-mips64.h"  // NOLINT
60 #elif V8_TARGET_ARCH_X87
61 #include "src/x87/codegen-x87.h"  // NOLINT
62 #else
63 #error Unsupported target architecture.
64 #endif
65 
66 namespace v8 {
67 namespace internal {
68 
69 
70 class CompilationInfo;
71 
72 
73 class CodeGenerator {
74  public:
75   // Printing of AST, etc. as requested by flags.
76   static void MakeCodePrologue(CompilationInfo* info, const char* kind);
77 
78   // Allocate and install the code.
79   static Handle<Code> MakeCodeEpilogue(MacroAssembler* masm,
80                                        Code::Flags flags,
81                                        CompilationInfo* info);
82 
83   // Print the code after compiling it.
84   static void PrintCode(Handle<Code> code, CompilationInfo* info);
85 
86   static bool RecordPositions(MacroAssembler* masm,
87                               int pos,
88                               bool right_here = false);
89 
90  private:
91   DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
92 };
93 
94 
95 // Results of the library implementation of transcendental functions may differ
96 // from the one we use in our generated code.  Therefore we use the same
97 // generated code both in runtime and compiled code.
98 typedef double (*UnaryMathFunction)(double x);
99 
100 UnaryMathFunction CreateExpFunction();
101 UnaryMathFunction CreateSqrtFunction();
102 
103 
104 double modulo(double x, double y);
105 
106 // Custom implementation of math functions.
107 double fast_exp(double input);
108 double fast_sqrt(double input);
109 #ifdef _WIN64
110 void init_modulo_function();
111 #endif
112 void lazily_initialize_fast_exp();
113 void init_fast_sqrt_function();
114 
115 
116 class ElementsTransitionGenerator : public AllStatic {
117  public:
118   // If |mode| is set to DONT_TRACK_ALLOCATION_SITE,
119   // |allocation_memento_found| may be NULL.
120   static void GenerateMapChangeElementsTransition(
121       MacroAssembler* masm,
122       Register receiver,
123       Register key,
124       Register value,
125       Register target_map,
126       AllocationSiteMode mode,
127       Label* allocation_memento_found);
128   static void GenerateSmiToDouble(
129       MacroAssembler* masm,
130       Register receiver,
131       Register key,
132       Register value,
133       Register target_map,
134       AllocationSiteMode mode,
135       Label* fail);
136   static void GenerateDoubleToObject(
137       MacroAssembler* masm,
138       Register receiver,
139       Register key,
140       Register value,
141       Register target_map,
142       AllocationSiteMode mode,
143       Label* fail);
144 
145  private:
146   DISALLOW_COPY_AND_ASSIGN(ElementsTransitionGenerator);
147 };
148 
149 static const int kNumberDictionaryProbes = 4;
150 
151 
152 class CodeAgingHelper {
153  public:
154   CodeAgingHelper();
155 
young_sequence_length()156   uint32_t young_sequence_length() const { return young_sequence_.length(); }
IsYoung(byte * candidate)157   bool IsYoung(byte* candidate) const {
158     return memcmp(candidate,
159                   young_sequence_.start(),
160                   young_sequence_.length()) == 0;
161   }
CopyYoungSequenceTo(byte * new_buffer)162   void CopyYoungSequenceTo(byte* new_buffer) const {
163     CopyBytes(new_buffer, young_sequence_.start(), young_sequence_.length());
164   }
165 
166 #ifdef DEBUG
167   bool IsOld(byte* candidate) const;
168 #endif
169 
170  protected:
171   const EmbeddedVector<byte, kNoCodeAgeSequenceLength> young_sequence_;
172 #ifdef DEBUG
173 #ifdef V8_TARGET_ARCH_ARM64
174   const EmbeddedVector<byte, kNoCodeAgeSequenceLength> old_sequence_;
175 #endif
176 #endif
177 };
178 
179 } }  // namespace v8::internal
180 
181 #endif  // V8_CODEGEN_H_
182