1 // Copyright 2013 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/v8.h"
6 
7 #include "src/lithium-codegen.h"
8 
9 #if V8_TARGET_ARCH_IA32
10 #include "src/ia32/lithium-ia32.h"  // NOLINT
11 #include "src/ia32/lithium-codegen-ia32.h"  // NOLINT
12 #elif V8_TARGET_ARCH_X64
13 #include "src/x64/lithium-x64.h"  // NOLINT
14 #include "src/x64/lithium-codegen-x64.h"  // NOLINT
15 #elif V8_TARGET_ARCH_ARM
16 #include "src/arm/lithium-arm.h"  // NOLINT
17 #include "src/arm/lithium-codegen-arm.h"  // NOLINT
18 #elif V8_TARGET_ARCH_ARM64
19 #include "src/arm64/lithium-arm64.h"  // NOLINT
20 #include "src/arm64/lithium-codegen-arm64.h"  // NOLINT
21 #elif V8_TARGET_ARCH_MIPS
22 #include "src/mips/lithium-mips.h"  // NOLINT
23 #include "src/mips/lithium-codegen-mips.h"  // NOLINT
24 #elif V8_TARGET_ARCH_MIPS64
25 #include "src/mips64/lithium-mips64.h"  // NOLINT
26 #include "src/mips64/lithium-codegen-mips64.h"  // NOLINT
27 #elif V8_TARGET_ARCH_X87
28 #include "src/x87/lithium-x87.h"  // NOLINT
29 #include "src/x87/lithium-codegen-x87.h"  // NOLINT
30 #else
31 #error Unsupported target architecture.
32 #endif
33 
34 namespace v8 {
35 namespace internal {
36 
37 
graph() const38 HGraph* LCodeGenBase::graph() const {
39   return chunk()->graph();
40 }
41 
42 
LCodeGenBase(LChunk * chunk,MacroAssembler * assembler,CompilationInfo * info)43 LCodeGenBase::LCodeGenBase(LChunk* chunk,
44                            MacroAssembler* assembler,
45                            CompilationInfo* info)
46     : chunk_(static_cast<LPlatformChunk*>(chunk)),
47       masm_(assembler),
48       info_(info),
49       zone_(info->zone()),
50       status_(UNUSED),
51       current_block_(-1),
52       current_instruction_(-1),
53       instructions_(chunk->instructions()),
54       last_lazy_deopt_pc_(0) {
55 }
56 
57 
GenerateBody()58 bool LCodeGenBase::GenerateBody() {
59   DCHECK(is_generating());
60   bool emit_instructions = true;
61   LCodeGen* codegen = static_cast<LCodeGen*>(this);
62   for (current_instruction_ = 0;
63        !is_aborted() && current_instruction_ < instructions_->length();
64        current_instruction_++) {
65     LInstruction* instr = instructions_->at(current_instruction_);
66 
67     // Don't emit code for basic blocks with a replacement.
68     if (instr->IsLabel()) {
69       emit_instructions = !LLabel::cast(instr)->HasReplacement() &&
70           (!FLAG_unreachable_code_elimination ||
71            instr->hydrogen_value()->block()->IsReachable());
72       if (FLAG_code_comments && !emit_instructions) {
73         Comment(
74             ";;; <@%d,#%d> -------------------- B%d (unreachable/replaced) "
75             "--------------------",
76             current_instruction_,
77             instr->hydrogen_value()->id(),
78             instr->hydrogen_value()->block()->block_id());
79       }
80     }
81     if (!emit_instructions) continue;
82 
83     if (FLAG_code_comments && instr->HasInterestingComment(codegen)) {
84       Comment(";;; <@%d,#%d> %s",
85               current_instruction_,
86               instr->hydrogen_value()->id(),
87               instr->Mnemonic());
88     }
89 
90     GenerateBodyInstructionPre(instr);
91 
92     HValue* value = instr->hydrogen_value();
93     if (!value->position().IsUnknown()) {
94       RecordAndWritePosition(
95         chunk()->graph()->SourcePositionToScriptPosition(value->position()));
96     }
97 
98     instr->CompileToNative(codegen);
99 
100     GenerateBodyInstructionPost(instr);
101   }
102   EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());
103   last_lazy_deopt_pc_ = masm()->pc_offset();
104   return !is_aborted();
105 }
106 
107 
CheckEnvironmentUsage()108 void LCodeGenBase::CheckEnvironmentUsage() {
109 #ifdef DEBUG
110   bool dead_block = false;
111   for (int i = 0; i < instructions_->length(); i++) {
112     LInstruction* instr = instructions_->at(i);
113     HValue* hval = instr->hydrogen_value();
114     if (instr->IsLabel()) dead_block = LLabel::cast(instr)->HasReplacement();
115     if (dead_block || !hval->block()->IsReachable()) continue;
116 
117     HInstruction* hinstr = HInstruction::cast(hval);
118     if (!hinstr->CanDeoptimize() && instr->HasEnvironment()) {
119       V8_Fatal(__FILE__, __LINE__, "CanDeoptimize is wrong for %s (%s)",
120                hinstr->Mnemonic(), instr->Mnemonic());
121     }
122 
123     if (instr->HasEnvironment() && !instr->environment()->has_been_used()) {
124       V8_Fatal(__FILE__, __LINE__, "unused environment for %s (%s)",
125                hinstr->Mnemonic(), instr->Mnemonic());
126     }
127   }
128 #endif
129 }
130 
131 
Comment(const char * format,...)132 void LCodeGenBase::Comment(const char* format, ...) {
133   if (!FLAG_code_comments) return;
134   char buffer[4 * KB];
135   StringBuilder builder(buffer, arraysize(buffer));
136   va_list arguments;
137   va_start(arguments, format);
138   builder.AddFormattedList(format, arguments);
139   va_end(arguments);
140 
141   // Copy the string before recording it in the assembler to avoid
142   // issues when the stack allocated buffer goes out of scope.
143   size_t length = builder.position();
144   Vector<char> copy = Vector<char>::New(static_cast<int>(length) + 1);
145   MemCopy(copy.start(), builder.Finalize(), copy.length());
146   masm()->RecordComment(copy.start());
147 }
148 
149 
DeoptComment(const Deoptimizer::Reason & reason)150 void LCodeGenBase::DeoptComment(const Deoptimizer::Reason& reason) {
151   OStringStream os;
152   os << ";;; deoptimize at " << HSourcePosition(reason.raw_position) << " "
153      << reason.mnemonic;
154   if (reason.detail != NULL) os << ": " << reason.detail;
155   Comment("%s", os.c_str());
156 }
157 
158 
GetNextEmittedBlock() const159 int LCodeGenBase::GetNextEmittedBlock() const {
160   for (int i = current_block_ + 1; i < graph()->blocks()->length(); ++i) {
161     if (!graph()->blocks()->at(i)->IsReachable()) continue;
162     if (!chunk_->GetLabel(i)->HasReplacement()) return i;
163   }
164   return -1;
165 }
166 
167 
AddWeakObjectToCodeDependency(Isolate * isolate,Handle<Object> object,Handle<Code> code)168 static void AddWeakObjectToCodeDependency(Isolate* isolate,
169                                           Handle<Object> object,
170                                           Handle<Code> code) {
171   Heap* heap = isolate->heap();
172   heap->EnsureWeakObjectToCodeTable();
173   Handle<DependentCode> dep(heap->LookupWeakObjectToCodeDependency(object));
174   dep = DependentCode::Insert(dep, DependentCode::kWeakCodeGroup, code);
175   heap->AddWeakObjectToCodeDependency(object, dep);
176 }
177 
178 
RegisterWeakObjectsInOptimizedCode(Handle<Code> code)179 void LCodeGenBase::RegisterWeakObjectsInOptimizedCode(Handle<Code> code) {
180   DCHECK(code->is_optimized_code());
181   ZoneList<Handle<Map> > maps(1, zone());
182   ZoneList<Handle<JSObject> > objects(1, zone());
183   ZoneList<Handle<Cell> > cells(1, zone());
184   int mode_mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
185                   RelocInfo::ModeMask(RelocInfo::CELL);
186   for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
187     RelocInfo::Mode mode = it.rinfo()->rmode();
188     if (mode == RelocInfo::CELL &&
189         code->IsWeakObjectInOptimizedCode(it.rinfo()->target_cell())) {
190       Handle<Cell> cell(it.rinfo()->target_cell());
191       cells.Add(cell, zone());
192     } else if (mode == RelocInfo::EMBEDDED_OBJECT &&
193                code->IsWeakObjectInOptimizedCode(it.rinfo()->target_object())) {
194       if (it.rinfo()->target_object()->IsMap()) {
195         Handle<Map> map(Map::cast(it.rinfo()->target_object()));
196         maps.Add(map, zone());
197       } else if (it.rinfo()->target_object()->IsJSObject()) {
198         Handle<JSObject> object(JSObject::cast(it.rinfo()->target_object()));
199         objects.Add(object, zone());
200       } else if (it.rinfo()->target_object()->IsCell()) {
201         Handle<Cell> cell(Cell::cast(it.rinfo()->target_object()));
202         cells.Add(cell, zone());
203       }
204     }
205   }
206   if (FLAG_enable_ool_constant_pool) {
207     code->constant_pool()->set_weak_object_state(
208         ConstantPoolArray::WEAK_OBJECTS_IN_OPTIMIZED_CODE);
209   }
210 #ifdef VERIFY_HEAP
211   // This disables verification of weak embedded objects after full GC.
212   // AddDependentCode can cause a GC, which would observe the state where
213   // this code is not yet in the depended code lists of the embedded maps.
214   NoWeakObjectVerificationScope disable_verification_of_embedded_objects;
215 #endif
216   for (int i = 0; i < maps.length(); i++) {
217     Map::AddDependentCode(maps.at(i), DependentCode::kWeakCodeGroup, code);
218   }
219   for (int i = 0; i < objects.length(); i++) {
220     AddWeakObjectToCodeDependency(isolate(), objects.at(i), code);
221   }
222   for (int i = 0; i < cells.length(); i++) {
223     AddWeakObjectToCodeDependency(isolate(), cells.at(i), code);
224   }
225 }
226 
227 
Abort(BailoutReason reason)228 void LCodeGenBase::Abort(BailoutReason reason) {
229   info()->AbortOptimization(reason);
230   status_ = ABORTED;
231 }
232 
233 
Retry(BailoutReason reason)234 void LCodeGenBase::Retry(BailoutReason reason) {
235   info()->RetryOptimization(reason);
236   status_ = ABORTED;
237 }
238 
239 
AddDeprecationDependency(Handle<Map> map)240 void LCodeGenBase::AddDeprecationDependency(Handle<Map> map) {
241   if (map->is_deprecated()) return Retry(kMapBecameDeprecated);
242   chunk_->AddDeprecationDependency(map);
243 }
244 
245 
AddStabilityDependency(Handle<Map> map)246 void LCodeGenBase::AddStabilityDependency(Handle<Map> map) {
247   if (!map->is_stable()) return Retry(kMapBecameUnstable);
248   chunk_->AddStabilityDependency(map);
249 }
250 
251 } }  // namespace v8::internal
252