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 #include "src/codegen.h"
6
7 #if defined(V8_OS_AIX)
8 #include <fenv.h> // NOLINT(build/c++11)
9 #endif
10
11 #include <memory>
12
13 #include "src/ast/prettyprinter.h"
14 #include "src/bootstrapper.h"
15 #include "src/compilation-info.h"
16 #include "src/debug/debug.h"
17 #include "src/eh-frame.h"
18 #include "src/runtime/runtime.h"
19
20 namespace v8 {
21 namespace internal {
22
23
24 #if defined(V8_OS_WIN)
modulo(double x,double y)25 double modulo(double x, double y) {
26 // Workaround MS fmod bugs. ECMA-262 says:
27 // dividend is finite and divisor is an infinity => result equals dividend
28 // dividend is a zero and divisor is nonzero finite => result equals dividend
29 if (!(std::isfinite(x) && (!std::isfinite(y) && !std::isnan(y))) &&
30 !(x == 0 && (y != 0 && std::isfinite(y)))) {
31 x = fmod(x, y);
32 }
33 return x;
34 }
35 #else // POSIX
36
37 double modulo(double x, double y) {
38 #if defined(V8_OS_AIX)
39 // AIX raises an underflow exception for (Number.MIN_VALUE % Number.MAX_VALUE)
40 feclearexcept(FE_ALL_EXCEPT);
41 double result = std::fmod(x, y);
42 int exception = fetestexcept(FE_UNDERFLOW);
43 return (exception ? x : result);
44 #else
45 return std::fmod(x, y);
46 #endif
47 }
48 #endif // defined(V8_OS_WIN)
49
50
51 #define UNARY_MATH_FUNCTION(name, generator) \
52 static UnaryMathFunctionWithIsolate fast_##name##_function = nullptr; \
53 double std_##name(double x, Isolate* isolate) { return std::name(x); } \
54 void init_fast_##name##_function(Isolate* isolate) { \
55 if (FLAG_fast_math) fast_##name##_function = generator(isolate); \
56 if (!fast_##name##_function) fast_##name##_function = std_##name; \
57 } \
58 void lazily_initialize_fast_##name(Isolate* isolate) { \
59 if (!fast_##name##_function) init_fast_##name##_function(isolate); \
60 } \
61 double fast_##name(double x, Isolate* isolate) { \
62 return (*fast_##name##_function)(x, isolate); \
63 }
64
UNARY_MATH_FUNCTION(sqrt,CreateSqrtFunction)65 UNARY_MATH_FUNCTION(sqrt, CreateSqrtFunction)
66
67 #undef UNARY_MATH_FUNCTION
68
69
70 #define __ ACCESS_MASM(masm_)
71
72 #ifdef DEBUG
73
74 Comment::Comment(MacroAssembler* masm, const char* msg)
75 : masm_(masm), msg_(msg) {
76 __ RecordComment(msg);
77 }
78
79
~Comment()80 Comment::~Comment() {
81 if (msg_[0] == '[') __ RecordComment("]");
82 }
83
84 #endif // DEBUG
85
86 #undef __
87
88
MakeCodePrologue(CompilationInfo * info,const char * kind)89 void CodeGenerator::MakeCodePrologue(CompilationInfo* info, const char* kind) {
90 bool print_ast = false;
91 const char* ftype;
92
93 if (info->isolate()->bootstrapper()->IsActive()) {
94 print_ast = FLAG_print_builtin_ast;
95 ftype = "builtin";
96 } else {
97 print_ast = FLAG_print_ast;
98 ftype = "user-defined";
99 }
100
101 if (FLAG_trace_codegen || print_ast) {
102 std::unique_ptr<char[]> name = info->GetDebugName();
103 PrintF("[generating %s code for %s function: %s]\n", kind, ftype,
104 name.get());
105 }
106
107 #ifdef DEBUG
108 if (info->parse_info() && print_ast) {
109 PrintF("--- AST ---\n%s\n",
110 AstPrinter(info->isolate()).PrintProgram(info->literal()));
111 }
112 #endif // DEBUG
113 }
114
MakeCodeEpilogue(MacroAssembler * masm,EhFrameWriter * eh_frame_writer,CompilationInfo * info,Handle<Object> self_reference)115 Handle<Code> CodeGenerator::MakeCodeEpilogue(MacroAssembler* masm,
116 EhFrameWriter* eh_frame_writer,
117 CompilationInfo* info,
118 Handle<Object> self_reference) {
119 Isolate* isolate = info->isolate();
120
121 // Allocate and install the code.
122 CodeDesc desc;
123 Code::Flags flags = info->code_flags();
124 bool is_crankshafted =
125 Code::ExtractKindFromFlags(flags) == Code::OPTIMIZED_FUNCTION ||
126 info->IsStub();
127 masm->GetCode(&desc);
128 if (eh_frame_writer) eh_frame_writer->GetEhFrame(&desc);
129
130 Handle<Code> code = isolate->factory()->NewCode(
131 desc, flags, self_reference, false, is_crankshafted,
132 info->prologue_offset(), info->is_debug() && !is_crankshafted);
133 isolate->counters()->total_compiled_code_size()->Increment(
134 code->instruction_size());
135 isolate->heap()->IncrementCodeGeneratedBytes(is_crankshafted,
136 code->instruction_size());
137 return code;
138 }
139
140
PrintCode(Handle<Code> code,CompilationInfo * info)141 void CodeGenerator::PrintCode(Handle<Code> code, CompilationInfo* info) {
142 #ifdef ENABLE_DISASSEMBLER
143 AllowDeferredHandleDereference allow_deference_for_print_code;
144 Isolate* isolate = info->isolate();
145 bool print_code =
146 isolate->bootstrapper()->IsActive()
147 ? FLAG_print_builtin_code
148 : (FLAG_print_code || (info->IsStub() && FLAG_print_code_stubs) ||
149 (info->IsOptimizing() && FLAG_print_opt_code &&
150 info->shared_info()->PassesFilter(FLAG_print_opt_code_filter)));
151 if (print_code) {
152 std::unique_ptr<char[]> debug_name = info->GetDebugName();
153 CodeTracer::Scope tracing_scope(info->isolate()->GetCodeTracer());
154 OFStream os(tracing_scope.file());
155
156 // Print the source code if available.
157 bool print_source =
158 info->parse_info() && (code->kind() == Code::OPTIMIZED_FUNCTION ||
159 code->kind() == Code::FUNCTION);
160 if (print_source) {
161 Handle<SharedFunctionInfo> shared = info->shared_info();
162 Handle<Script> script = info->script();
163 if (!script->IsUndefined(isolate) &&
164 !script->source()->IsUndefined(isolate)) {
165 os << "--- Raw source ---\n";
166 StringCharacterStream stream(String::cast(script->source()),
167 shared->start_position());
168 // fun->end_position() points to the last character in the stream. We
169 // need to compensate by adding one to calculate the length.
170 int source_len = shared->end_position() - shared->start_position() + 1;
171 for (int i = 0; i < source_len; i++) {
172 if (stream.HasMore()) {
173 os << AsReversiblyEscapedUC16(stream.GetNext());
174 }
175 }
176 os << "\n\n";
177 }
178 }
179 if (info->IsOptimizing()) {
180 if (FLAG_print_unopt_code && info->parse_info()) {
181 os << "--- Unoptimized code ---\n";
182 info->closure()->shared()->code()->Disassemble(debug_name.get(), os);
183 }
184 os << "--- Optimized code ---\n"
185 << "optimization_id = " << info->optimization_id() << "\n";
186 } else {
187 os << "--- Code ---\n";
188 }
189 if (print_source) {
190 Handle<SharedFunctionInfo> shared = info->shared_info();
191 os << "source_position = " << shared->start_position() << "\n";
192 }
193 code->Disassemble(debug_name.get(), os);
194 os << "--- End code ---\n";
195 }
196 #endif // ENABLE_DISASSEMBLER
197 }
198
199 } // namespace internal
200 } // namespace v8
201