blob: 294d005073b89acedb5de73632823d96733a9953 [file] [log] [blame]
Shih-wei Liaod1fec812012-02-13 09:51:10 -08001/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "method_compiler.h"
18
Logan Chienfca7e872011-12-20 20:08:22 +080019#include "backend_types.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080020#include "compiler.h"
Logan Chiena78e3c82011-12-27 17:59:35 +080021#include "inferred_reg_category_map.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080022#include "ir_builder.h"
23#include "logging.h"
Logan Chien4dd96f52012-02-29 01:26:58 +080024#include "oat_compilation_unit.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080025#include "object.h"
26#include "object_utils.h"
Logan Chien42e0e152012-01-13 15:42:36 +080027#include "runtime_support_func.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080028#include "stl_util.h"
Logan Chien0b827102011-12-20 19:46:14 +080029#include "stringprintf.h"
30#include "utils_llvm.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080031
32#include <iomanip>
33
34#include <llvm/Analysis/Verifier.h>
Logan Chienc670a8d2011-12-20 21:25:56 +080035#include <llvm/BasicBlock.h>
Shih-wei Liaod1fec812012-02-13 09:51:10 -080036#include <llvm/Function.h>
Logan Chiena85fb2f2012-01-16 12:52:56 +080037#include <llvm/GlobalVariable.h>
38#include <llvm/Intrinsics.h>
Shih-wei Liaod1fec812012-02-13 09:51:10 -080039
Logan Chien83426162011-12-09 09:29:50 +080040namespace art {
41namespace compiler_llvm {
Shih-wei Liaod1fec812012-02-13 09:51:10 -080042
Logan Chien42e0e152012-01-13 15:42:36 +080043using namespace runtime_support;
44
Shih-wei Liaod1fec812012-02-13 09:51:10 -080045
Logan Chien83426162011-12-09 09:29:50 +080046MethodCompiler::MethodCompiler(InstructionSet insn_set,
47 Compiler* compiler,
Logan Chien4dd96f52012-02-29 01:26:58 +080048 OatCompilationUnit* oat_compilation_unit)
49: insn_set_(insn_set), compiler_(compiler),
50 compiler_llvm_(compiler->GetCompilerLLVM()),
51 class_linker_(oat_compilation_unit->class_linker_),
52 class_loader_(oat_compilation_unit->class_loader_),
53 dex_file_(oat_compilation_unit->dex_file_),
54 dex_cache_(oat_compilation_unit->dex_cache_),
55 code_item_(oat_compilation_unit->code_item_),
56 oat_compilation_unit_(oat_compilation_unit),
57 method_(dex_cache_->GetResolvedMethod(oat_compilation_unit->method_idx_)),
58 method_helper_(method_),
59 method_idx_(oat_compilation_unit->method_idx_),
60 access_flags_(oat_compilation_unit->access_flags_),
61 module_(compiler_llvm_->GetModule()),
Shih-wei Liaod1fec812012-02-13 09:51:10 -080062 context_(compiler_llvm_->GetLLVMContext()),
Logan Chienc670a8d2011-12-20 21:25:56 +080063 irb_(*compiler_llvm_->GetIRBuilder()), func_(NULL), retval_reg_(NULL),
Logan Chien8dfcbea2012-02-17 18:50:32 +080064 basic_block_reg_alloca_(NULL), basic_block_shadow_frame_alloca_(NULL),
Logan Chiend6ececa2011-12-27 16:20:15 +080065 basic_block_reg_zero_init_(NULL), basic_block_reg_arg_init_(NULL),
Logan Chien4dd96f52012-02-29 01:26:58 +080066 basic_blocks_(code_item_->insns_size_in_code_units_),
67 basic_block_landing_pads_(code_item_->tries_size_, NULL),
Logan Chien8dfcbea2012-02-17 18:50:32 +080068 basic_block_unwind_(NULL), basic_block_unreachable_(NULL),
69 shadow_frame_(NULL) {
Shih-wei Liaod1fec812012-02-13 09:51:10 -080070}
71
72
73MethodCompiler::~MethodCompiler() {
Logan Chienc670a8d2011-12-20 21:25:56 +080074 STLDeleteElements(&regs_);
Shih-wei Liaod1fec812012-02-13 09:51:10 -080075}
76
77
Logan Chien0b827102011-12-20 19:46:14 +080078void MethodCompiler::CreateFunction() {
79 // LLVM function name
80 std::string func_name(LLVMLongName(method_));
81
82 // Get function type
83 llvm::FunctionType* func_type =
84 GetFunctionType(method_idx_, method_->IsStatic());
85
86 // Create function
87 func_ = llvm::Function::Create(func_type, llvm::Function::ExternalLinkage,
88 func_name, module_);
89
90 // Set argument name
91 llvm::Function::arg_iterator arg_iter(func_->arg_begin());
92 llvm::Function::arg_iterator arg_end(func_->arg_end());
93
94 DCHECK_NE(arg_iter, arg_end);
95 arg_iter->setName("method");
96 ++arg_iter;
97
98 if (!method_->IsStatic()) {
99 DCHECK_NE(arg_iter, arg_end);
100 arg_iter->setName("this");
101 ++arg_iter;
102 }
103
104 for (unsigned i = 0; arg_iter != arg_end; ++i, ++arg_iter) {
105 arg_iter->setName(StringPrintf("a%u", i));
106 }
107}
108
109
110llvm::FunctionType* MethodCompiler::GetFunctionType(uint32_t method_idx,
111 bool is_static) {
112 // Get method signature
113 DexFile::MethodId const& method_id = dex_file_->GetMethodId(method_idx);
114
Logan Chien8faf8022012-02-24 12:25:29 +0800115 uint32_t shorty_size;
Logan Chien0b827102011-12-20 19:46:14 +0800116 char const* shorty = dex_file_->GetMethodShorty(method_id, &shorty_size);
Logan Chien8faf8022012-02-24 12:25:29 +0800117 CHECK_GE(shorty_size, 1u);
Logan Chien0b827102011-12-20 19:46:14 +0800118
119 // Get return type
120 llvm::Type* ret_type = irb_.getJType(shorty[0], kAccurate);
121
122 // Get argument type
123 std::vector<llvm::Type*> args_type;
124
125 args_type.push_back(irb_.getJObjectTy()); // method object pointer
126
127 if (!is_static) {
128 args_type.push_back(irb_.getJType('L', kAccurate)); // "this" object pointer
129 }
130
Logan Chien8faf8022012-02-24 12:25:29 +0800131 for (uint32_t i = 1; i < shorty_size; ++i) {
Logan Chien0b827102011-12-20 19:46:14 +0800132 args_type.push_back(irb_.getJType(shorty[i], kAccurate));
133 }
134
135 return llvm::FunctionType::get(ret_type, args_type, false);
136}
137
138
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800139void MethodCompiler::EmitPrologue() {
Logan Chienc670a8d2011-12-20 21:25:56 +0800140 // Create basic blocks for prologue
141 basic_block_reg_alloca_ =
142 llvm::BasicBlock::Create(*context_, "prologue.alloca", func_);
143
Logan Chien8dfcbea2012-02-17 18:50:32 +0800144 basic_block_shadow_frame_alloca_ =
145 llvm::BasicBlock::Create(*context_, "prologue.shadowframe", func_);
146
Logan Chienc670a8d2011-12-20 21:25:56 +0800147 basic_block_reg_zero_init_ =
148 llvm::BasicBlock::Create(*context_, "prologue.zeroinit", func_);
149
Logan Chiend6ececa2011-12-27 16:20:15 +0800150 basic_block_reg_arg_init_ =
151 llvm::BasicBlock::Create(*context_, "prologue.arginit", func_);
152
Logan Chienc670a8d2011-12-20 21:25:56 +0800153 // Create register array
154 for (uint16_t r = 0; r < code_item_->registers_size_; ++r) {
155 regs_.push_back(DalvikReg::CreateLocalVarReg(*this, r));
156 }
157
158 retval_reg_.reset(DalvikReg::CreateRetValReg(*this));
Logan Chiend6ececa2011-12-27 16:20:15 +0800159
Logan Chien8dfcbea2012-02-17 18:50:32 +0800160 // Create Shadow Frame
161 EmitPrologueAllocShadowFrame();
162
Logan Chiend6ececa2011-12-27 16:20:15 +0800163 // Store argument to dalvik register
164 irb_.SetInsertPoint(basic_block_reg_arg_init_);
165 EmitPrologueAssignArgRegister();
166
167 // Branch to start address
168 irb_.CreateBr(GetBasicBlock(0));
Logan Chienc670a8d2011-12-20 21:25:56 +0800169}
170
171
172void MethodCompiler::EmitPrologueLastBranch() {
173 irb_.SetInsertPoint(basic_block_reg_alloca_);
Logan Chien8dfcbea2012-02-17 18:50:32 +0800174 irb_.CreateBr(basic_block_shadow_frame_alloca_);
175
176 irb_.SetInsertPoint(basic_block_shadow_frame_alloca_);
Logan Chienc670a8d2011-12-20 21:25:56 +0800177 irb_.CreateBr(basic_block_reg_zero_init_);
178
179 irb_.SetInsertPoint(basic_block_reg_zero_init_);
Logan Chiend6ececa2011-12-27 16:20:15 +0800180 irb_.CreateBr(basic_block_reg_arg_init_);
181}
182
183
Logan Chien8dfcbea2012-02-17 18:50:32 +0800184void MethodCompiler::EmitPrologueAllocShadowFrame() {
185 irb_.SetInsertPoint(basic_block_shadow_frame_alloca_);
186
187 // Allocate the shadow frame now!
188 uint32_t sirt_size = code_item_->registers_size_;
189 // TODO: registers_size_ is a bad approximation. Compute a
190 // tighter approximation at Dex verifier while performing data-flow
191 // analysis.
192
193 llvm::StructType* shadow_frame_type = irb_.getShadowFrameTy(sirt_size);
194 shadow_frame_ = irb_.CreateAlloca(shadow_frame_type);
195
196 // Zero-initialization of the shadow frame
197 llvm::ConstantAggregateZero* zero_initializer =
198 llvm::ConstantAggregateZero::get(shadow_frame_type);
199
200 irb_.CreateStore(zero_initializer, shadow_frame_);
201
202 // Variables for GetElementPtr
203 llvm::Constant* zero = irb_.getInt32(0);
204
205 llvm::Value* gep_index[] = {
206 zero, // No displacement for shadow frame pointer
207 zero, // Get the %ArtFrame data structure
208 NULL,
209 };
210
211 // Store the method pointer
212 gep_index[2] = irb_.getInt32(1);
213 llvm::Value* method_field_addr = irb_.CreateGEP(shadow_frame_, gep_index);
214 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
215 irb_.CreateStore(method_object_addr, method_field_addr);
216
217 // Store the number of the pointer slots
218 gep_index[2] = irb_.getInt32(3);
219 llvm::Value* size_field_addr = irb_.CreateGEP(shadow_frame_, gep_index);
220 llvm::ConstantInt* sirt_size_value = irb_.getInt32(sirt_size);
221 irb_.CreateStore(sirt_size_value, size_field_addr);
222
223 // Push the shadow frame
224 llvm::Value* shadow_frame_upcast =
225 irb_.CreateConstGEP2_32(shadow_frame_, 0, 0);
226
227 irb_.CreateCall(irb_.GetRuntime(PushShadowFrame), shadow_frame_upcast);
228}
229
230
Logan Chiend6ececa2011-12-27 16:20:15 +0800231void MethodCompiler::EmitPrologueAssignArgRegister() {
232 uint16_t arg_reg = code_item_->registers_size_ - code_item_->ins_size_;
233
234 llvm::Function::arg_iterator arg_iter(func_->arg_begin());
235 llvm::Function::arg_iterator arg_end(func_->arg_end());
236
237 char const* shorty = method_helper_.GetShorty();
238 int32_t shorty_size = method_helper_.GetShortyLength();
239 CHECK_LE(1, shorty_size);
240
241 ++arg_iter; // skip method object
242
243 if (!method_->IsStatic()) {
244 EmitStoreDalvikReg(arg_reg, kObject, kAccurate, arg_iter);
245 ++arg_iter;
246 ++arg_reg;
247 }
248
249 for (int32_t i = 1; i < shorty_size; ++i, ++arg_iter) {
250 EmitStoreDalvikReg(arg_reg, shorty[i], kAccurate, arg_iter);
251
252 ++arg_reg;
253 if (shorty[i] == 'J' || shorty[i] == 'D') {
254 // Wide types, such as long and double, are using a pair of registers
255 // to store the value, so we have to increase arg_reg again.
256 ++arg_reg;
257 }
258 }
259
260 DCHECK_EQ(arg_end, arg_iter);
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800261}
262
263
Logan Chien83426162011-12-09 09:29:50 +0800264void MethodCompiler::EmitInstructions() {
Logan Chiend6c239a2011-12-23 15:11:45 +0800265 uint32_t dex_pc = 0;
266 while (dex_pc < code_item_->insns_size_in_code_units_) {
267 Instruction const* insn = Instruction::At(code_item_->insns_ + dex_pc);
268 EmitInstruction(dex_pc, insn);
269 dex_pc += insn->SizeInCodeUnits();
270 }
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800271}
272
273
Logan Chien83426162011-12-09 09:29:50 +0800274void MethodCompiler::EmitInstruction(uint32_t dex_pc,
275 Instruction const* insn) {
Logan Chiend6c239a2011-12-23 15:11:45 +0800276
277 // Set the IRBuilder insertion point
278 irb_.SetInsertPoint(GetBasicBlock(dex_pc));
279
Logan Chien70f94b42011-12-27 17:49:11 +0800280#define ARGS dex_pc, insn
281
282 // Dispatch the instruction
283 switch (insn->Opcode()) {
284 case Instruction::NOP:
285 EmitInsn_Nop(ARGS);
286 break;
287
288 case Instruction::MOVE:
289 case Instruction::MOVE_FROM16:
290 case Instruction::MOVE_16:
291 EmitInsn_Move(ARGS, kInt);
292 break;
293
294 case Instruction::MOVE_WIDE:
295 case Instruction::MOVE_WIDE_FROM16:
296 case Instruction::MOVE_WIDE_16:
297 EmitInsn_Move(ARGS, kLong);
298 break;
299
300 case Instruction::MOVE_OBJECT:
301 case Instruction::MOVE_OBJECT_FROM16:
302 case Instruction::MOVE_OBJECT_16:
303 EmitInsn_Move(ARGS, kObject);
304 break;
305
306 case Instruction::MOVE_RESULT:
307 EmitInsn_MoveResult(ARGS, kInt);
308 break;
309
310 case Instruction::MOVE_RESULT_WIDE:
311 EmitInsn_MoveResult(ARGS, kLong);
312 break;
313
314 case Instruction::MOVE_RESULT_OBJECT:
315 EmitInsn_MoveResult(ARGS, kObject);
316 break;
317
318 case Instruction::MOVE_EXCEPTION:
319 EmitInsn_MoveException(ARGS);
320 break;
321
322 case Instruction::RETURN_VOID:
323 EmitInsn_ReturnVoid(ARGS);
324 break;
325
326 case Instruction::RETURN:
327 case Instruction::RETURN_WIDE:
328 case Instruction::RETURN_OBJECT:
329 EmitInsn_Return(ARGS);
330 break;
331
332 case Instruction::CONST_4:
333 case Instruction::CONST_16:
334 case Instruction::CONST:
335 case Instruction::CONST_HIGH16:
336 EmitInsn_LoadConstant(ARGS, kInt);
337 break;
338
339 case Instruction::CONST_WIDE_16:
340 case Instruction::CONST_WIDE_32:
341 case Instruction::CONST_WIDE:
342 case Instruction::CONST_WIDE_HIGH16:
343 EmitInsn_LoadConstant(ARGS, kLong);
344 break;
345
346 case Instruction::CONST_STRING:
347 case Instruction::CONST_STRING_JUMBO:
348 EmitInsn_LoadConstantString(ARGS);
349 break;
350
351 case Instruction::CONST_CLASS:
352 EmitInsn_LoadConstantClass(ARGS);
353 break;
354
355 case Instruction::MONITOR_ENTER:
356 EmitInsn_MonitorEnter(ARGS);
357 break;
358
359 case Instruction::MONITOR_EXIT:
360 EmitInsn_MonitorExit(ARGS);
361 break;
362
363 case Instruction::CHECK_CAST:
364 EmitInsn_CheckCast(ARGS);
365 break;
366
367 case Instruction::INSTANCE_OF:
368 EmitInsn_InstanceOf(ARGS);
369 break;
370
371 case Instruction::ARRAY_LENGTH:
372 EmitInsn_ArrayLength(ARGS);
373 break;
374
375 case Instruction::NEW_INSTANCE:
376 EmitInsn_NewInstance(ARGS);
377 break;
378
379 case Instruction::NEW_ARRAY:
380 EmitInsn_NewArray(ARGS);
381 break;
382
383 case Instruction::FILLED_NEW_ARRAY:
384 EmitInsn_FilledNewArray(ARGS, false);
385 break;
386
387 case Instruction::FILLED_NEW_ARRAY_RANGE:
388 EmitInsn_FilledNewArray(ARGS, true);
389 break;
390
391 case Instruction::FILL_ARRAY_DATA:
392 EmitInsn_FillArrayData(ARGS);
393 break;
394
395 case Instruction::THROW:
396 EmitInsn_ThrowException(ARGS);
397 break;
398
399 case Instruction::GOTO:
400 case Instruction::GOTO_16:
401 case Instruction::GOTO_32:
402 EmitInsn_UnconditionalBranch(ARGS);
403 break;
404
405 case Instruction::PACKED_SWITCH:
406 EmitInsn_PackedSwitch(ARGS);
407 break;
408
409 case Instruction::SPARSE_SWITCH:
410 EmitInsn_SparseSwitch(ARGS);
411 break;
412
413 case Instruction::CMPL_FLOAT:
414 EmitInsn_FPCompare(ARGS, kFloat, false);
415 break;
416
417 case Instruction::CMPG_FLOAT:
418 EmitInsn_FPCompare(ARGS, kFloat, true);
419 break;
420
421 case Instruction::CMPL_DOUBLE:
422 EmitInsn_FPCompare(ARGS, kDouble, false);
423 break;
424
425 case Instruction::CMPG_DOUBLE:
426 EmitInsn_FPCompare(ARGS, kDouble, true);
427 break;
428
429 case Instruction::CMP_LONG:
430 EmitInsn_LongCompare(ARGS);
431 break;
432
433 case Instruction::IF_EQ:
434 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_EQ);
435 break;
436
437 case Instruction::IF_NE:
438 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_NE);
439 break;
440
441 case Instruction::IF_LT:
442 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_LT);
443 break;
444
445 case Instruction::IF_GE:
446 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_GE);
447 break;
448
449 case Instruction::IF_GT:
450 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_GT);
451 break;
452
453 case Instruction::IF_LE:
454 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_LE);
455 break;
456
457 case Instruction::IF_EQZ:
458 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_EQ);
459 break;
460
461 case Instruction::IF_NEZ:
462 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_NE);
463 break;
464
465 case Instruction::IF_LTZ:
466 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_LT);
467 break;
468
469 case Instruction::IF_GEZ:
470 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_GE);
471 break;
472
473 case Instruction::IF_GTZ:
474 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_GT);
475 break;
476
477 case Instruction::IF_LEZ:
478 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_LE);
479 break;
480
481 case Instruction::AGET:
482 EmitInsn_AGet(ARGS, kInt);
483 break;
484
485 case Instruction::AGET_WIDE:
486 EmitInsn_AGet(ARGS, kLong);
487 break;
488
489 case Instruction::AGET_OBJECT:
490 EmitInsn_AGet(ARGS, kObject);
491 break;
492
493 case Instruction::AGET_BOOLEAN:
494 EmitInsn_AGet(ARGS, kBoolean);
495 break;
496
497 case Instruction::AGET_BYTE:
498 EmitInsn_AGet(ARGS, kByte);
499 break;
500
501 case Instruction::AGET_CHAR:
502 EmitInsn_AGet(ARGS, kChar);
503 break;
504
505 case Instruction::AGET_SHORT:
506 EmitInsn_AGet(ARGS, kShort);
507 break;
508
509 case Instruction::APUT:
510 EmitInsn_APut(ARGS, kInt);
511 break;
512
513 case Instruction::APUT_WIDE:
514 EmitInsn_APut(ARGS, kLong);
515 break;
516
517 case Instruction::APUT_OBJECT:
518 EmitInsn_APut(ARGS, kObject);
519 break;
520
521 case Instruction::APUT_BOOLEAN:
522 EmitInsn_APut(ARGS, kBoolean);
523 break;
524
525 case Instruction::APUT_BYTE:
526 EmitInsn_APut(ARGS, kByte);
527 break;
528
529 case Instruction::APUT_CHAR:
530 EmitInsn_APut(ARGS, kChar);
531 break;
532
533 case Instruction::APUT_SHORT:
534 EmitInsn_APut(ARGS, kShort);
535 break;
536
537 case Instruction::IGET:
538 EmitInsn_IGet(ARGS, kInt);
539 break;
540
541 case Instruction::IGET_WIDE:
542 EmitInsn_IGet(ARGS, kLong);
543 break;
544
545 case Instruction::IGET_OBJECT:
546 EmitInsn_IGet(ARGS, kObject);
547 break;
548
549 case Instruction::IGET_BOOLEAN:
550 EmitInsn_IGet(ARGS, kBoolean);
551 break;
552
553 case Instruction::IGET_BYTE:
554 EmitInsn_IGet(ARGS, kByte);
555 break;
556
557 case Instruction::IGET_CHAR:
558 EmitInsn_IGet(ARGS, kChar);
559 break;
560
561 case Instruction::IGET_SHORT:
562 EmitInsn_IGet(ARGS, kShort);
563 break;
564
565 case Instruction::IPUT:
566 EmitInsn_IPut(ARGS, kInt);
567 break;
568
569 case Instruction::IPUT_WIDE:
570 EmitInsn_IPut(ARGS, kLong);
571 break;
572
573 case Instruction::IPUT_OBJECT:
574 EmitInsn_IPut(ARGS, kObject);
575 break;
576
577 case Instruction::IPUT_BOOLEAN:
578 EmitInsn_IPut(ARGS, kBoolean);
579 break;
580
581 case Instruction::IPUT_BYTE:
582 EmitInsn_IPut(ARGS, kByte);
583 break;
584
585 case Instruction::IPUT_CHAR:
586 EmitInsn_IPut(ARGS, kChar);
587 break;
588
589 case Instruction::IPUT_SHORT:
590 EmitInsn_IPut(ARGS, kShort);
591 break;
592
593 case Instruction::SGET:
594 EmitInsn_SGet(ARGS, kInt);
595 break;
596
597 case Instruction::SGET_WIDE:
598 EmitInsn_SGet(ARGS, kLong);
599 break;
600
601 case Instruction::SGET_OBJECT:
602 EmitInsn_SGet(ARGS, kObject);
603 break;
604
605 case Instruction::SGET_BOOLEAN:
606 EmitInsn_SGet(ARGS, kBoolean);
607 break;
608
609 case Instruction::SGET_BYTE:
610 EmitInsn_SGet(ARGS, kByte);
611 break;
612
613 case Instruction::SGET_CHAR:
614 EmitInsn_SGet(ARGS, kChar);
615 break;
616
617 case Instruction::SGET_SHORT:
618 EmitInsn_SGet(ARGS, kShort);
619 break;
620
621 case Instruction::SPUT:
622 EmitInsn_SPut(ARGS, kInt);
623 break;
624
625 case Instruction::SPUT_WIDE:
626 EmitInsn_SPut(ARGS, kLong);
627 break;
628
629 case Instruction::SPUT_OBJECT:
630 EmitInsn_SPut(ARGS, kObject);
631 break;
632
633 case Instruction::SPUT_BOOLEAN:
634 EmitInsn_SPut(ARGS, kBoolean);
635 break;
636
637 case Instruction::SPUT_BYTE:
638 EmitInsn_SPut(ARGS, kByte);
639 break;
640
641 case Instruction::SPUT_CHAR:
642 EmitInsn_SPut(ARGS, kChar);
643 break;
644
645 case Instruction::SPUT_SHORT:
646 EmitInsn_SPut(ARGS, kShort);
647 break;
648
649
650 case Instruction::INVOKE_VIRTUAL:
651 EmitInsn_InvokeVirtual(ARGS, false);
652 break;
653
654 case Instruction::INVOKE_SUPER:
655 EmitInsn_InvokeSuper(ARGS, false);
656 break;
657
658 case Instruction::INVOKE_DIRECT:
Logan Chien61c65dc2012-02-29 03:22:30 +0800659 EmitInsn_InvokeStaticDirect(ARGS, kDirect, /* is_range */ false);
Logan Chien70f94b42011-12-27 17:49:11 +0800660 break;
661
662 case Instruction::INVOKE_STATIC:
Logan Chien61c65dc2012-02-29 03:22:30 +0800663 EmitInsn_InvokeStaticDirect(ARGS, kStatic, /* is_range */ false);
Logan Chien70f94b42011-12-27 17:49:11 +0800664 break;
665
666 case Instruction::INVOKE_INTERFACE:
667 EmitInsn_InvokeInterface(ARGS, false);
668 break;
669
670 case Instruction::INVOKE_VIRTUAL_RANGE:
671 EmitInsn_InvokeVirtual(ARGS, true);
672 break;
673
674 case Instruction::INVOKE_SUPER_RANGE:
675 EmitInsn_InvokeSuper(ARGS, true);
676 break;
677
678 case Instruction::INVOKE_DIRECT_RANGE:
Logan Chien61c65dc2012-02-29 03:22:30 +0800679 EmitInsn_InvokeStaticDirect(ARGS, kDirect, true);
Logan Chien70f94b42011-12-27 17:49:11 +0800680 break;
681
682 case Instruction::INVOKE_STATIC_RANGE:
Logan Chien61c65dc2012-02-29 03:22:30 +0800683 EmitInsn_InvokeStaticDirect(ARGS, kStatic, true);
Logan Chien70f94b42011-12-27 17:49:11 +0800684 break;
685
686 case Instruction::INVOKE_INTERFACE_RANGE:
687 EmitInsn_InvokeInterface(ARGS, true);
688 break;
689
690 case Instruction::NEG_INT:
691 EmitInsn_Neg(ARGS, kInt);
692 break;
693
694 case Instruction::NOT_INT:
695 EmitInsn_Not(ARGS, kInt);
696 break;
697
698 case Instruction::NEG_LONG:
699 EmitInsn_Neg(ARGS, kLong);
700 break;
701
702 case Instruction::NOT_LONG:
703 EmitInsn_Not(ARGS, kLong);
704 break;
705
706 case Instruction::NEG_FLOAT:
707 EmitInsn_FNeg(ARGS, kFloat);
708 break;
709
710 case Instruction::NEG_DOUBLE:
711 EmitInsn_FNeg(ARGS, kDouble);
712 break;
713
714 case Instruction::INT_TO_LONG:
715 EmitInsn_SExt(ARGS);
716 break;
717
718 case Instruction::INT_TO_FLOAT:
719 EmitInsn_IntToFP(ARGS, kInt, kFloat);
720 break;
721
722 case Instruction::INT_TO_DOUBLE:
723 EmitInsn_IntToFP(ARGS, kInt, kDouble);
724 break;
725
726 case Instruction::LONG_TO_INT:
727 EmitInsn_Trunc(ARGS);
728 break;
729
730 case Instruction::LONG_TO_FLOAT:
731 EmitInsn_IntToFP(ARGS, kLong, kFloat);
732 break;
733
734 case Instruction::LONG_TO_DOUBLE:
735 EmitInsn_IntToFP(ARGS, kLong, kDouble);
736 break;
737
738 case Instruction::FLOAT_TO_INT:
739 EmitInsn_FPToInt(ARGS, kFloat, kInt);
740 break;
741
742 case Instruction::FLOAT_TO_LONG:
743 EmitInsn_FPToInt(ARGS, kFloat, kLong);
744 break;
745
746 case Instruction::FLOAT_TO_DOUBLE:
747 EmitInsn_FExt(ARGS);
748 break;
749
750 case Instruction::DOUBLE_TO_INT:
751 EmitInsn_FPToInt(ARGS, kDouble, kInt);
752 break;
753
754 case Instruction::DOUBLE_TO_LONG:
755 EmitInsn_FPToInt(ARGS, kDouble, kLong);
756 break;
757
758 case Instruction::DOUBLE_TO_FLOAT:
759 EmitInsn_FTrunc(ARGS);
760 break;
761
762 case Instruction::INT_TO_BYTE:
763 EmitInsn_TruncAndSExt(ARGS, 8);
764 break;
765
766 case Instruction::INT_TO_CHAR:
767 EmitInsn_TruncAndZExt(ARGS, 16);
768 break;
769
770 case Instruction::INT_TO_SHORT:
771 EmitInsn_TruncAndSExt(ARGS, 16);
772 break;
773
774 case Instruction::ADD_INT:
775 EmitInsn_IntArithm(ARGS, kIntArithm_Add, kInt, false);
776 break;
777
778 case Instruction::SUB_INT:
779 EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kInt, false);
780 break;
781
782 case Instruction::MUL_INT:
783 EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kInt, false);
784 break;
785
786 case Instruction::DIV_INT:
787 EmitInsn_IntArithm(ARGS, kIntArithm_Div, kInt, false);
788 break;
789
790 case Instruction::REM_INT:
791 EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kInt, false);
792 break;
793
794 case Instruction::AND_INT:
795 EmitInsn_IntArithm(ARGS, kIntArithm_And, kInt, false);
796 break;
797
798 case Instruction::OR_INT:
799 EmitInsn_IntArithm(ARGS, kIntArithm_Or, kInt, false);
800 break;
801
802 case Instruction::XOR_INT:
803 EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kInt, false);
804 break;
805
806 case Instruction::SHL_INT:
807 EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kInt, false);
808 break;
809
810 case Instruction::SHR_INT:
811 EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kInt, false);
812 break;
813
814 case Instruction::USHR_INT:
815 EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kInt, false);
816 break;
817
818 case Instruction::ADD_LONG:
819 EmitInsn_IntArithm(ARGS, kIntArithm_Add, kLong, false);
820 break;
821
822 case Instruction::SUB_LONG:
823 EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kLong, false);
824 break;
825
826 case Instruction::MUL_LONG:
827 EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kLong, false);
828 break;
829
830 case Instruction::DIV_LONG:
831 EmitInsn_IntArithm(ARGS, kIntArithm_Div, kLong, false);
832 break;
833
834 case Instruction::REM_LONG:
835 EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kLong, false);
836 break;
837
838 case Instruction::AND_LONG:
839 EmitInsn_IntArithm(ARGS, kIntArithm_And, kLong, false);
840 break;
841
842 case Instruction::OR_LONG:
843 EmitInsn_IntArithm(ARGS, kIntArithm_Or, kLong, false);
844 break;
845
846 case Instruction::XOR_LONG:
847 EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kLong, false);
848 break;
849
850 case Instruction::SHL_LONG:
851 EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kLong, false);
852 break;
853
854 case Instruction::SHR_LONG:
855 EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kLong, false);
856 break;
857
858 case Instruction::USHR_LONG:
859 EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kLong, false);
860 break;
861
862 case Instruction::ADD_FLOAT:
863 EmitInsn_FPArithm(ARGS, kFPArithm_Add, kFloat, false);
864 break;
865
866 case Instruction::SUB_FLOAT:
867 EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kFloat, false);
868 break;
869
870 case Instruction::MUL_FLOAT:
871 EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kFloat, false);
872 break;
873
874 case Instruction::DIV_FLOAT:
875 EmitInsn_FPArithm(ARGS, kFPArithm_Div, kFloat, false);
876 break;
877
878 case Instruction::REM_FLOAT:
879 EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kFloat, false);
880 break;
881
882 case Instruction::ADD_DOUBLE:
883 EmitInsn_FPArithm(ARGS, kFPArithm_Add, kDouble, false);
884 break;
885
886 case Instruction::SUB_DOUBLE:
887 EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kDouble, false);
888 break;
889
890 case Instruction::MUL_DOUBLE:
891 EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kDouble, false);
892 break;
893
894 case Instruction::DIV_DOUBLE:
895 EmitInsn_FPArithm(ARGS, kFPArithm_Div, kDouble, false);
896 break;
897
898 case Instruction::REM_DOUBLE:
899 EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kDouble, false);
900 break;
901
902 case Instruction::ADD_INT_2ADDR:
903 EmitInsn_IntArithm(ARGS, kIntArithm_Add, kInt, true);
904 break;
905
906 case Instruction::SUB_INT_2ADDR:
907 EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kInt, true);
908 break;
909
910 case Instruction::MUL_INT_2ADDR:
911 EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kInt, true);
912 break;
913
914 case Instruction::DIV_INT_2ADDR:
915 EmitInsn_IntArithm(ARGS, kIntArithm_Div, kInt, true);
916 break;
917
918 case Instruction::REM_INT_2ADDR:
919 EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kInt, true);
920 break;
921
922 case Instruction::AND_INT_2ADDR:
923 EmitInsn_IntArithm(ARGS, kIntArithm_And, kInt, true);
924 break;
925
926 case Instruction::OR_INT_2ADDR:
927 EmitInsn_IntArithm(ARGS, kIntArithm_Or, kInt, true);
928 break;
929
930 case Instruction::XOR_INT_2ADDR:
931 EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kInt, true);
932 break;
933
934 case Instruction::SHL_INT_2ADDR:
935 EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kInt, true);
936 break;
937
938 case Instruction::SHR_INT_2ADDR:
939 EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kInt, true);
940 break;
941
942 case Instruction::USHR_INT_2ADDR:
943 EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kInt, true);
944 break;
945
946 case Instruction::ADD_LONG_2ADDR:
947 EmitInsn_IntArithm(ARGS, kIntArithm_Add, kLong, true);
948 break;
949
950 case Instruction::SUB_LONG_2ADDR:
951 EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kLong, true);
952 break;
953
954 case Instruction::MUL_LONG_2ADDR:
955 EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kLong, true);
956 break;
957
958 case Instruction::DIV_LONG_2ADDR:
959 EmitInsn_IntArithm(ARGS, kIntArithm_Div, kLong, true);
960 break;
961
962 case Instruction::REM_LONG_2ADDR:
963 EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kLong, true);
964 break;
965
966 case Instruction::AND_LONG_2ADDR:
967 EmitInsn_IntArithm(ARGS, kIntArithm_And, kLong, true);
968 break;
969
970 case Instruction::OR_LONG_2ADDR:
971 EmitInsn_IntArithm(ARGS, kIntArithm_Or, kLong, true);
972 break;
973
974 case Instruction::XOR_LONG_2ADDR:
975 EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kLong, true);
976 break;
977
978 case Instruction::SHL_LONG_2ADDR:
979 EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kLong, true);
980 break;
981
982 case Instruction::SHR_LONG_2ADDR:
983 EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kLong, true);
984 break;
985
986 case Instruction::USHR_LONG_2ADDR:
987 EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kLong, true);
988 break;
989
990 case Instruction::ADD_FLOAT_2ADDR:
991 EmitInsn_FPArithm(ARGS, kFPArithm_Add, kFloat, true);
992 break;
993
994 case Instruction::SUB_FLOAT_2ADDR:
995 EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kFloat, true);
996 break;
997
998 case Instruction::MUL_FLOAT_2ADDR:
999 EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kFloat, true);
1000 break;
1001
1002 case Instruction::DIV_FLOAT_2ADDR:
1003 EmitInsn_FPArithm(ARGS, kFPArithm_Div, kFloat, true);
1004 break;
1005
1006 case Instruction::REM_FLOAT_2ADDR:
1007 EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kFloat, true);
1008 break;
1009
1010 case Instruction::ADD_DOUBLE_2ADDR:
1011 EmitInsn_FPArithm(ARGS, kFPArithm_Add, kDouble, true);
1012 break;
1013
1014 case Instruction::SUB_DOUBLE_2ADDR:
1015 EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kDouble, true);
1016 break;
1017
1018 case Instruction::MUL_DOUBLE_2ADDR:
1019 EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kDouble, true);
1020 break;
1021
1022 case Instruction::DIV_DOUBLE_2ADDR:
1023 EmitInsn_FPArithm(ARGS, kFPArithm_Div, kDouble, true);
1024 break;
1025
1026 case Instruction::REM_DOUBLE_2ADDR:
1027 EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kDouble, true);
1028 break;
1029
1030 case Instruction::ADD_INT_LIT16:
1031 case Instruction::ADD_INT_LIT8:
1032 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Add);
1033 break;
1034
1035 case Instruction::RSUB_INT:
1036 case Instruction::RSUB_INT_LIT8:
1037 EmitInsn_RSubImmediate(ARGS);
1038 break;
1039
1040 case Instruction::MUL_INT_LIT16:
1041 case Instruction::MUL_INT_LIT8:
1042 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Mul);
1043 break;
1044
1045 case Instruction::DIV_INT_LIT16:
1046 case Instruction::DIV_INT_LIT8:
1047 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Div);
1048 break;
1049
1050 case Instruction::REM_INT_LIT16:
1051 case Instruction::REM_INT_LIT8:
1052 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Rem);
1053 break;
1054
1055 case Instruction::AND_INT_LIT16:
1056 case Instruction::AND_INT_LIT8:
1057 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_And);
1058 break;
1059
1060 case Instruction::OR_INT_LIT16:
1061 case Instruction::OR_INT_LIT8:
1062 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Or);
1063 break;
1064
1065 case Instruction::XOR_INT_LIT16:
1066 case Instruction::XOR_INT_LIT8:
1067 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Xor);
1068 break;
1069
1070 case Instruction::SHL_INT_LIT8:
1071 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Shl);
1072 break;
1073
1074 case Instruction::SHR_INT_LIT8:
1075 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Shr);
1076 break;
1077
1078 case Instruction::USHR_INT_LIT8:
1079 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_UShr);
1080 break;
1081
1082 case Instruction::UNUSED_3E:
1083 case Instruction::UNUSED_3F:
1084 case Instruction::UNUSED_40:
1085 case Instruction::UNUSED_41:
1086 case Instruction::UNUSED_42:
1087 case Instruction::UNUSED_43:
1088 case Instruction::UNUSED_73:
1089 case Instruction::UNUSED_79:
1090 case Instruction::UNUSED_7A:
1091 case Instruction::UNUSED_E3:
1092 case Instruction::UNUSED_E4:
1093 case Instruction::UNUSED_E5:
1094 case Instruction::UNUSED_E6:
1095 case Instruction::UNUSED_E7:
1096 case Instruction::UNUSED_E8:
1097 case Instruction::UNUSED_E9:
1098 case Instruction::UNUSED_EA:
1099 case Instruction::UNUSED_EB:
1100 case Instruction::UNUSED_EC:
1101 case Instruction::THROW_VERIFICATION_ERROR:
1102 case Instruction::UNUSED_EE:
1103 case Instruction::UNUSED_EF:
1104 case Instruction::UNUSED_F0:
1105 case Instruction::UNUSED_F1:
1106 case Instruction::UNUSED_F2:
1107 case Instruction::UNUSED_F3:
1108 case Instruction::UNUSED_F4:
1109 case Instruction::UNUSED_F5:
1110 case Instruction::UNUSED_F6:
1111 case Instruction::UNUSED_F7:
1112 case Instruction::UNUSED_F8:
1113 case Instruction::UNUSED_F9:
1114 case Instruction::UNUSED_FA:
1115 case Instruction::UNUSED_FB:
1116 case Instruction::UNUSED_FC:
1117 case Instruction::UNUSED_FD:
1118 case Instruction::UNUSED_FE:
1119 case Instruction::UNUSED_FF:
1120 LOG(FATAL) << "Dex file contains UNUSED bytecode: " << insn->Opcode();
1121 break;
1122 }
1123
1124#undef ARGS
1125}
1126
1127
1128void MethodCompiler::EmitInsn_Nop(uint32_t dex_pc,
1129 Instruction const* insn) {
Logan Chiene09a6b72011-12-27 17:50:21 +08001130
1131 uint16_t insn_signature = code_item_->insns_[dex_pc];
1132
1133 if (insn_signature == Instruction::kPackedSwitchSignature ||
1134 insn_signature == Instruction::kSparseSwitchSignature ||
1135 insn_signature == Instruction::kArrayDataSignature) {
1136 irb_.CreateUnreachable();
1137 } else{
1138 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1139 }
Shih-wei Liaod1fec812012-02-13 09:51:10 -08001140}
1141
1142
Logan Chien70f94b42011-12-27 17:49:11 +08001143void MethodCompiler::EmitInsn_Move(uint32_t dex_pc,
1144 Instruction const* insn,
1145 JType jty) {
Logan Chien48173132011-12-27 17:51:13 +08001146
1147 Instruction::DecodedInstruction dec_insn(insn);
1148
1149 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, jty, kReg);
1150 EmitStoreDalvikReg(dec_insn.vA_, jty, kReg, src_value);
1151
Logan Chien70f94b42011-12-27 17:49:11 +08001152 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1153}
1154
1155
1156void MethodCompiler::EmitInsn_MoveResult(uint32_t dex_pc,
1157 Instruction const* insn,
1158 JType jty) {
Logan Chien48173132011-12-27 17:51:13 +08001159
1160 Instruction::DecodedInstruction dec_insn(insn);
1161
1162 llvm::Value* src_value = EmitLoadDalvikRetValReg(jty, kReg);
1163 EmitStoreDalvikReg(dec_insn.vA_, jty, kReg, src_value);
1164
Logan Chien70f94b42011-12-27 17:49:11 +08001165 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1166}
1167
1168
1169void MethodCompiler::EmitInsn_MoveException(uint32_t dex_pc,
1170 Instruction const* insn) {
Logan Chien3354cec2012-01-13 14:29:03 +08001171
1172 Instruction::DecodedInstruction dec_insn(insn);
1173
1174 // Get thread-local exception field address
1175 llvm::Constant* exception_field_offset =
1176 irb_.getPtrEquivInt(Thread::ExceptionOffset().Int32Value());
1177
1178 llvm::Value* thread_object_addr =
1179 irb_.CreateCall(irb_.GetRuntime(GetCurrentThread));
1180
1181 llvm::Value* exception_field_addr =
1182 irb_.CreatePtrDisp(thread_object_addr, exception_field_offset,
1183 irb_.getJObjectTy()->getPointerTo());
1184
1185 // Get exception object address
1186 llvm::Value* exception_object_addr = irb_.CreateLoad(exception_field_addr);
1187
1188 // Set thread-local exception field address to NULL
1189 irb_.CreateStore(irb_.getJNull(), exception_field_addr);
1190
1191 // Keep the exception object in the Dalvik register
1192 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, exception_object_addr);
1193
Logan Chien70f94b42011-12-27 17:49:11 +08001194 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1195}
1196
1197
1198void MethodCompiler::EmitInsn_ThrowException(uint32_t dex_pc,
1199 Instruction const* insn) {
Logan Chien6c6f12d2012-01-13 19:26:27 +08001200
1201 Instruction::DecodedInstruction dec_insn(insn);
1202
1203 llvm::Value* exception_addr =
1204 EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1205
Logan Chien8dfcbea2012-02-17 18:50:32 +08001206 EmitUpdateLineNumFromDexPC(dex_pc);
1207
Logan Chien6c6f12d2012-01-13 19:26:27 +08001208 irb_.CreateCall(irb_.GetRuntime(ThrowException), exception_addr);
1209
1210 EmitBranchExceptionLandingPad(dex_pc);
Logan Chien70f94b42011-12-27 17:49:11 +08001211}
1212
1213
1214void MethodCompiler::EmitInsn_ReturnVoid(uint32_t dex_pc,
1215 Instruction const* insn) {
Logan Chien8898a272011-12-27 17:51:56 +08001216 // Garbage collection safe-point
1217 EmitGuard_GarbageCollectionSuspend(dex_pc);
1218
Logan Chien8dfcbea2012-02-17 18:50:32 +08001219 // Pop the shadow frame
1220 EmitPopShadowFrame();
1221
Logan Chien8898a272011-12-27 17:51:56 +08001222 // Return!
1223 irb_.CreateRetVoid();
Logan Chien70f94b42011-12-27 17:49:11 +08001224}
1225
1226
1227void MethodCompiler::EmitInsn_Return(uint32_t dex_pc,
1228 Instruction const* insn) {
Logan Chien8898a272011-12-27 17:51:56 +08001229
1230 Instruction::DecodedInstruction dec_insn(insn);
1231
1232 // Garbage collection safe-point
1233 EmitGuard_GarbageCollectionSuspend(dex_pc);
1234
Logan Chien8dfcbea2012-02-17 18:50:32 +08001235 // Pop the shadow frame
1236 EmitPopShadowFrame();
1237 // NOTE: It is important to keep this AFTER the GC safe-point. Otherwise,
1238 // the return value might be collected since the shadow stack is popped.
1239
Logan Chien8898a272011-12-27 17:51:56 +08001240 // Return!
1241 char ret_shorty = method_helper_.GetShorty()[0];
1242 llvm::Value* retval = EmitLoadDalvikReg(dec_insn.vA_, ret_shorty, kAccurate);
1243
1244 irb_.CreateRet(retval);
Logan Chien70f94b42011-12-27 17:49:11 +08001245}
1246
1247
1248void MethodCompiler::EmitInsn_LoadConstant(uint32_t dex_pc,
1249 Instruction const* insn,
1250 JType imm_jty) {
Shih-wei Liao798366e2012-02-16 09:25:33 -08001251
1252 Instruction::DecodedInstruction dec_insn(insn);
1253
1254 DCHECK(imm_jty == kInt || imm_jty == kLong) << imm_jty;
1255
1256 int64_t imm = 0;
1257
1258 switch (insn->Opcode()) {
1259 // 32-bit Immediate
1260 case Instruction::CONST_4:
1261 case Instruction::CONST_16:
1262 case Instruction::CONST:
1263 case Instruction::CONST_WIDE_16:
1264 case Instruction::CONST_WIDE_32:
1265 imm = static_cast<int64_t>(static_cast<int32_t>(dec_insn.vB_));
1266 break;
1267
1268 case Instruction::CONST_HIGH16:
1269 imm = static_cast<int64_t>(static_cast<int32_t>(
1270 static_cast<uint32_t>(static_cast<uint16_t>(dec_insn.vB_)) << 16));
1271 break;
1272
1273 // 64-bit Immediate
1274 case Instruction::CONST_WIDE:
1275 imm = static_cast<int64_t>(dec_insn.vB_wide_);
1276 break;
1277
1278 case Instruction::CONST_WIDE_HIGH16:
1279 imm = static_cast<int64_t>(
1280 static_cast<uint64_t>(static_cast<uint16_t>(dec_insn.vB_)) << 48);
1281 break;
1282
1283 // Unknown opcode for load constant (unreachable)
1284 default:
1285 LOG(FATAL) << "Unknown opcode for load constant: " << insn->Opcode();
1286 break;
1287 }
1288
1289 // Store the non-object register
1290 llvm::Type* imm_type = irb_.getJType(imm_jty, kAccurate);
1291 llvm::Constant* imm_value = llvm::ConstantInt::getSigned(imm_type, imm);
1292 EmitStoreDalvikReg(dec_insn.vA_, imm_jty, kAccurate, imm_value);
1293
1294 // Store the object register if it is possible to be null.
1295 if (imm_jty == kInt && imm == 0) {
1296 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, irb_.getJNull());
1297 }
1298
Logan Chien70f94b42011-12-27 17:49:11 +08001299 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1300}
1301
1302
1303void MethodCompiler::EmitInsn_LoadConstantString(uint32_t dex_pc,
1304 Instruction const* insn) {
Logan Chienc3b4ba12012-01-16 19:52:53 +08001305
1306 Instruction::DecodedInstruction dec_insn(insn);
1307
1308 uint32_t string_idx = dec_insn.vB_;
1309
1310 llvm::Value* string_field_addr = EmitLoadDexCacheStringFieldAddr(string_idx);
1311
1312 llvm::Value* string_addr = irb_.CreateLoad(string_field_addr);
1313
1314 if (!compiler_->CanAssumeStringIsPresentInDexCache(dex_cache_, string_idx)) {
1315 llvm::BasicBlock* block_str_exist =
1316 CreateBasicBlockWithDexPC(dex_pc, "str_exist");
1317
1318 llvm::BasicBlock* block_str_resolve =
1319 CreateBasicBlockWithDexPC(dex_pc, "str_resolve");
1320
1321 // Test: Is the string resolved and in the dex cache?
1322 llvm::Value* equal_null = irb_.CreateICmpEQ(string_addr, irb_.getJNull());
1323
1324 irb_.CreateCondBr(equal_null, block_str_exist, block_str_resolve);
1325
1326 // String is resolved, go to next basic block.
1327 irb_.SetInsertPoint(block_str_exist);
1328 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, string_addr);
1329 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1330
1331 // String is not resolved yet, resolve it now.
1332 irb_.SetInsertPoint(block_str_resolve);
1333
1334 llvm::Function* runtime_func = irb_.GetRuntime(ResolveString);
1335
1336 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
1337
1338 llvm::Value* string_idx_value = irb_.getInt32(string_idx);
1339
Logan Chien8dfcbea2012-02-17 18:50:32 +08001340 EmitUpdateLineNumFromDexPC(dex_pc);
1341
1342 string_addr = irb_.CreateCall2(runtime_func, method_object_addr,
1343 string_idx_value);
Logan Chienc3b4ba12012-01-16 19:52:53 +08001344
1345 EmitGuard_ExceptionLandingPad(dex_pc);
1346 }
1347
1348 // Store the string object to the Dalvik register
1349 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, string_addr);
1350
Logan Chien70f94b42011-12-27 17:49:11 +08001351 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1352}
1353
1354
Logan Chien27b30252012-01-14 03:43:35 +08001355llvm::Value* MethodCompiler::EmitLoadConstantClass(uint32_t dex_pc,
1356 uint32_t type_idx) {
1357 if (!compiler_->CanAccessTypeWithoutChecks(method_idx_, dex_cache_,
1358 *dex_file_, type_idx)) {
1359 llvm::Value* type_idx_value = irb_.getInt32(type_idx);
1360
1361 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
1362
1363 llvm::Function* runtime_func =
1364 irb_.GetRuntime(InitializeTypeAndVerifyAccess);
1365
Logan Chien8dfcbea2012-02-17 18:50:32 +08001366 EmitUpdateLineNumFromDexPC(dex_pc);
1367
Logan Chien27b30252012-01-14 03:43:35 +08001368 llvm::Value* type_object_addr =
1369 irb_.CreateCall2(runtime_func, type_idx_value, method_object_addr);
1370
1371 EmitGuard_ExceptionLandingPad(dex_pc);
1372
1373 return type_object_addr;
1374
1375 } else {
1376 // Try to load the class (type) object from the test cache.
1377 llvm::Value* type_field_addr =
1378 EmitLoadDexCacheResolvedTypeFieldAddr(type_idx);
1379
1380 llvm::Value* type_object_addr = irb_.CreateLoad(type_field_addr);
1381
1382 if (compiler_->CanAssumeTypeIsPresentInDexCache(dex_cache_, type_idx)) {
1383 return type_object_addr;
1384 }
1385
1386 llvm::BasicBlock* block_original = irb_.GetInsertBlock();
1387
1388 // Test whether class (type) object is in the dex cache or not
1389 llvm::Value* equal_null =
1390 irb_.CreateICmpEQ(type_object_addr, irb_.getJNull());
1391
1392 llvm::BasicBlock* block_cont =
1393 CreateBasicBlockWithDexPC(dex_pc, "cont");
1394
1395 llvm::BasicBlock* block_load_class =
1396 CreateBasicBlockWithDexPC(dex_pc, "load_class");
1397
1398 irb_.CreateCondBr(equal_null, block_load_class, block_cont);
1399
1400 // Failback routine to load the class object
1401 irb_.SetInsertPoint(block_load_class);
1402
1403 llvm::Function* runtime_func = irb_.GetRuntime(InitializeType);
1404
1405 llvm::Constant* type_idx_value = irb_.getInt32(type_idx);
1406
1407 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
1408
Logan Chien8dfcbea2012-02-17 18:50:32 +08001409 EmitUpdateLineNumFromDexPC(dex_pc);
1410
Logan Chien27b30252012-01-14 03:43:35 +08001411 llvm::Value* loaded_type_object_addr =
1412 irb_.CreateCall2(runtime_func, type_idx_value, method_object_addr);
1413
1414 EmitGuard_ExceptionLandingPad(dex_pc);
1415
1416 llvm::BasicBlock* block_after_load_class = irb_.GetInsertBlock();
1417
1418 irb_.CreateBr(block_cont);
1419
1420 // Now the class object must be loaded
1421 irb_.SetInsertPoint(block_cont);
1422
1423 llvm::PHINode* phi = irb_.CreatePHI(irb_.getJObjectTy(), 2);
1424
1425 phi->addIncoming(type_object_addr, block_original);
1426 phi->addIncoming(loaded_type_object_addr, block_after_load_class);
1427
1428 return phi;
1429 }
1430}
1431
1432
Logan Chien70f94b42011-12-27 17:49:11 +08001433void MethodCompiler::EmitInsn_LoadConstantClass(uint32_t dex_pc,
1434 Instruction const* insn) {
Logan Chien27b30252012-01-14 03:43:35 +08001435
1436 Instruction::DecodedInstruction dec_insn(insn);
1437
1438 llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vB_);
1439 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, type_object_addr);
1440
Logan Chien70f94b42011-12-27 17:49:11 +08001441 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1442}
1443
1444
1445void MethodCompiler::EmitInsn_MonitorEnter(uint32_t dex_pc,
1446 Instruction const* insn) {
Logan Chien9e0dbe42012-01-13 12:11:37 +08001447
1448 Instruction::DecodedInstruction dec_insn(insn);
1449
1450 llvm::Value* object_addr =
1451 EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1452
1453 // TODO: Slow path always. May not need NullPointerException check.
1454 EmitGuard_NullPointerException(dex_pc, object_addr);
1455
Logan Chien8dfcbea2012-02-17 18:50:32 +08001456 EmitUpdateLineNumFromDexPC(dex_pc);
1457
Logan Chien9e0dbe42012-01-13 12:11:37 +08001458 irb_.CreateCall(irb_.GetRuntime(LockObject), object_addr);
1459 EmitGuard_ExceptionLandingPad(dex_pc);
1460
Logan Chien70f94b42011-12-27 17:49:11 +08001461 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1462}
1463
1464
1465void MethodCompiler::EmitInsn_MonitorExit(uint32_t dex_pc,
1466 Instruction const* insn) {
Logan Chien9e0dbe42012-01-13 12:11:37 +08001467
1468 Instruction::DecodedInstruction dec_insn(insn);
1469
1470 llvm::Value* object_addr =
1471 EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1472
1473 EmitGuard_NullPointerException(dex_pc, object_addr);
1474
Logan Chien8dfcbea2012-02-17 18:50:32 +08001475 EmitUpdateLineNumFromDexPC(dex_pc);
1476
Logan Chien9e0dbe42012-01-13 12:11:37 +08001477 irb_.CreateCall(irb_.GetRuntime(UnlockObject), object_addr);
1478 EmitGuard_ExceptionLandingPad(dex_pc);
1479
Logan Chien70f94b42011-12-27 17:49:11 +08001480 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1481}
1482
1483
1484void MethodCompiler::EmitInsn_CheckCast(uint32_t dex_pc,
1485 Instruction const* insn) {
Logan Chienfc880952012-01-15 23:53:10 +08001486
1487 Instruction::DecodedInstruction dec_insn(insn);
1488
1489 llvm::BasicBlock* block_test_class =
1490 CreateBasicBlockWithDexPC(dex_pc, "test_class");
1491
1492 llvm::BasicBlock* block_test_sub_class =
1493 CreateBasicBlockWithDexPC(dex_pc, "test_sub_class");
1494
1495 llvm::Value* object_addr =
1496 EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1497
1498 // Test: Is the reference equal to null? Act as no-op when it is null.
1499 llvm::Value* equal_null = irb_.CreateICmpEQ(object_addr, irb_.getJNull());
1500
1501 irb_.CreateCondBr(equal_null,
1502 GetNextBasicBlock(dex_pc),
1503 block_test_class);
1504
1505 // Test: Is the object instantiated from the given class?
1506 irb_.SetInsertPoint(block_test_class);
1507 llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vB_);
1508 DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
1509
1510 llvm::PointerType* jobject_ptr_ty = irb_.getJObjectTy();
1511
1512 llvm::Value* object_type_field_addr =
1513 irb_.CreateBitCast(object_addr, jobject_ptr_ty->getPointerTo());
1514
1515 llvm::Value* object_type_object_addr =
1516 irb_.CreateLoad(object_type_field_addr);
1517
1518 llvm::Value* equal_class =
1519 irb_.CreateICmpEQ(type_object_addr, object_type_object_addr);
1520
1521 irb_.CreateCondBr(equal_class,
1522 GetNextBasicBlock(dex_pc),
1523 block_test_sub_class);
1524
1525 // Test: Is the object instantiated from the subclass of the given class?
1526 irb_.SetInsertPoint(block_test_sub_class);
1527
Logan Chien8dfcbea2012-02-17 18:50:32 +08001528 EmitUpdateLineNumFromDexPC(dex_pc);
1529
Logan Chienfc880952012-01-15 23:53:10 +08001530 irb_.CreateCall2(irb_.GetRuntime(CheckCast),
1531 type_object_addr, object_type_object_addr);
1532
1533 EmitGuard_ExceptionLandingPad(dex_pc);
1534
Logan Chien70f94b42011-12-27 17:49:11 +08001535 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1536}
1537
1538
1539void MethodCompiler::EmitInsn_InstanceOf(uint32_t dex_pc,
1540 Instruction const* insn) {
Logan Chien68725e22012-01-15 22:25:34 +08001541
1542 Instruction::DecodedInstruction dec_insn(insn);
1543
1544 llvm::Constant* zero = irb_.getJInt(0);
1545 llvm::Constant* one = irb_.getJInt(1);
1546
1547 llvm::BasicBlock* block_nullp = CreateBasicBlockWithDexPC(dex_pc, "nullp");
1548
1549 llvm::BasicBlock* block_test_class =
1550 CreateBasicBlockWithDexPC(dex_pc, "test_class");
1551
1552 llvm::BasicBlock* block_class_equals =
1553 CreateBasicBlockWithDexPC(dex_pc, "class_eq");
1554
1555 llvm::BasicBlock* block_test_sub_class =
1556 CreateBasicBlockWithDexPC(dex_pc, "test_sub_class");
1557
1558 llvm::Value* object_addr =
1559 EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
1560
1561 // Overview of the following code :
1562 // We check for null, if so, then false, otherwise check for class == . If so
1563 // then true, otherwise do callout slowpath.
1564 //
1565 // Test: Is the reference equal to null? Set 0 when it is null.
1566 llvm::Value* equal_null = irb_.CreateICmpEQ(object_addr, irb_.getJNull());
1567
1568 irb_.CreateCondBr(equal_null, block_nullp, block_test_class);
1569
1570 irb_.SetInsertPoint(block_nullp);
1571 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, zero);
1572 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1573
1574 // Test: Is the object instantiated from the given class?
1575 irb_.SetInsertPoint(block_test_class);
1576 llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vC_);
1577 DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
1578
1579 llvm::PointerType* jobject_ptr_ty = irb_.getJObjectTy();
1580
1581 llvm::Value* object_type_field_addr =
1582 irb_.CreateBitCast(object_addr, jobject_ptr_ty->getPointerTo());
1583
1584 llvm::Value* object_type_object_addr =
1585 irb_.CreateLoad(object_type_field_addr);
1586
1587 llvm::Value* equal_class =
1588 irb_.CreateICmpEQ(type_object_addr, object_type_object_addr);
1589
1590 irb_.CreateCondBr(equal_class, block_class_equals, block_test_sub_class);
1591
1592 irb_.SetInsertPoint(block_class_equals);
1593 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, one);
1594 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1595
1596 // Test: Is the object instantiated from the subclass of the given class?
1597 irb_.SetInsertPoint(block_test_sub_class);
1598
1599 llvm::Value* result =
1600 irb_.CreateCall2(irb_.GetRuntime(IsAssignable),
1601 type_object_addr, object_type_object_addr);
1602
1603 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
1604
Logan Chien70f94b42011-12-27 17:49:11 +08001605 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1606}
1607
1608
Logan Chien61bb6142012-02-03 15:34:53 +08001609llvm::Value* MethodCompiler::EmitLoadArrayLength(llvm::Value* array) {
1610 // Load array length field address
1611 llvm::Constant* array_len_field_offset =
1612 irb_.getPtrEquivInt(Array::LengthOffset().Int32Value());
1613
1614 llvm::Value* array_len_field_addr =
1615 irb_.CreatePtrDisp(array, array_len_field_offset,
1616 irb_.getJIntTy()->getPointerTo());
1617
1618 // Load array length
1619 return irb_.CreateLoad(array_len_field_addr);
1620}
1621
1622
Logan Chien70f94b42011-12-27 17:49:11 +08001623void MethodCompiler::EmitInsn_ArrayLength(uint32_t dex_pc,
1624 Instruction const* insn) {
Logan Chien61bb6142012-02-03 15:34:53 +08001625
1626 Instruction::DecodedInstruction dec_insn(insn);
1627
1628 // Get the array object address
1629 llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
1630 EmitGuard_NullPointerException(dex_pc, array_addr);
1631
1632 // Get the array length and store it to the register
1633 llvm::Value* array_len = EmitLoadArrayLength(array_addr);
1634 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, array_len);
1635
Logan Chien70f94b42011-12-27 17:49:11 +08001636 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1637}
1638
1639
1640void MethodCompiler::EmitInsn_NewInstance(uint32_t dex_pc,
1641 Instruction const* insn) {
Logan Chien032bdad2012-01-16 09:59:23 +08001642
1643 Instruction::DecodedInstruction dec_insn(insn);
1644
1645 llvm::Function* runtime_func;
1646 if (compiler_->CanAccessTypeWithoutChecks(method_idx_, dex_cache_,
1647 *dex_file_, dec_insn.vB_)) {
1648 runtime_func = irb_.GetRuntime(AllocObject);
1649 } else {
1650 runtime_func = irb_.GetRuntime(AllocObjectWithAccessCheck);
1651 }
1652
1653 llvm::Constant* type_index_value = irb_.getInt32(dec_insn.vB_);
1654
1655 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
1656
Logan Chien8dfcbea2012-02-17 18:50:32 +08001657 EmitUpdateLineNumFromDexPC(dex_pc);
1658
Logan Chien032bdad2012-01-16 09:59:23 +08001659 llvm::Value* object_addr =
1660 irb_.CreateCall2(runtime_func, type_index_value, method_object_addr);
1661
1662 EmitGuard_ExceptionLandingPad(dex_pc);
1663
1664 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, object_addr);
1665
Logan Chien70f94b42011-12-27 17:49:11 +08001666 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1667}
1668
1669
Logan Chiena2cc6a32012-01-16 10:38:41 +08001670llvm::Value* MethodCompiler::EmitAllocNewArray(uint32_t dex_pc,
1671 int32_t length,
1672 uint32_t type_idx,
1673 bool is_filled_new_array) {
1674 llvm::Function* runtime_func;
1675
1676 bool skip_access_check =
1677 compiler_->CanAccessTypeWithoutChecks(method_idx_, dex_cache_,
1678 *dex_file_, type_idx);
1679
1680 if (is_filled_new_array) {
1681 runtime_func = skip_access_check ?
1682 irb_.GetRuntime(CheckAndAllocArray) :
1683 irb_.GetRuntime(CheckAndAllocArrayWithAccessCheck);
1684 } else {
1685 runtime_func = skip_access_check ?
1686 irb_.GetRuntime(AllocArray) :
1687 irb_.GetRuntime(AllocArrayWithAccessCheck);
1688 }
1689
1690 llvm::Constant* type_index_value = irb_.getInt32(type_idx);
1691
1692 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
1693
1694 llvm::Value* array_length_value = irb_.getInt32(length);
1695
Logan Chien8dfcbea2012-02-17 18:50:32 +08001696 EmitUpdateLineNumFromDexPC(dex_pc);
1697
Logan Chiena2cc6a32012-01-16 10:38:41 +08001698 llvm::Value* object_addr =
1699 irb_.CreateCall3(runtime_func, type_index_value, method_object_addr,
1700 array_length_value);
1701
1702 EmitGuard_ExceptionLandingPad(dex_pc);
1703
1704 return object_addr;
1705}
1706
1707
Logan Chien70f94b42011-12-27 17:49:11 +08001708void MethodCompiler::EmitInsn_NewArray(uint32_t dex_pc,
1709 Instruction const* insn) {
Logan Chiena2cc6a32012-01-16 10:38:41 +08001710
1711 Instruction::DecodedInstruction dec_insn(insn);
1712
1713 llvm::Value* object_addr =
1714 EmitAllocNewArray(dex_pc, dec_insn.vB_, dec_insn.vC_, false);
1715
1716 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, object_addr);
1717
Logan Chien70f94b42011-12-27 17:49:11 +08001718 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1719}
1720
1721
1722void MethodCompiler::EmitInsn_FilledNewArray(uint32_t dex_pc,
1723 Instruction const* insn,
1724 bool is_range) {
Logan Chiena85fb2f2012-01-16 12:52:56 +08001725
1726 Instruction::DecodedInstruction dec_insn(insn);
1727
1728 llvm::Value* object_addr =
1729 EmitAllocNewArray(dex_pc, dec_insn.vA_, dec_insn.vB_, true);
1730
1731 if (dec_insn.vA_ > 0) {
1732 llvm::Value* object_addr_int =
1733 irb_.CreatePtrToInt(object_addr, irb_.getPtrEquivIntTy());
1734
1735 llvm::Value* data_field_offset =
1736 irb_.getPtrEquivInt(Array::DataOffset().Int32Value());
1737
1738 llvm::Value* data_field_addr_int =
1739 irb_.CreateAdd(object_addr_int, data_field_offset);
1740
1741 Class* klass = method_->GetDexCacheResolvedTypes()->Get(dec_insn.vB_);
1742 CHECK_NE(klass, static_cast<Class*>(NULL));
1743 // Moved this below already: CHECK(!klass->IsPrimitive() || klass->IsPrimitiveInt());
1744
1745 llvm::Constant* word_size = irb_.getSizeOfPtrEquivIntValue();
1746
1747 llvm::Type* field_type;
1748 if (klass->IsPrimitiveInt()) {
1749 field_type = irb_.getJIntTy()->getPointerTo();
1750 } else {
1751 CHECK(!klass->IsPrimitive());
1752 field_type = irb_.getJObjectTy()->getPointerTo();
1753 }
1754
1755 // TODO: Tune this code. Currently we are generating one instruction for
1756 // one element which may be very space consuming. Maybe changing to use
1757 // memcpy may help; however, since we can't guarantee that the alloca of
1758 // dalvik register are continuous, we can't perform such optimization yet.
1759 for (uint32_t i = 0; i < dec_insn.vA_; ++i) {
1760 llvm::Value* data_field_addr =
1761 irb_.CreateIntToPtr(data_field_addr_int, field_type);
1762
1763 int reg_index;
1764 if (is_range) {
1765 reg_index = dec_insn.vC_ + i;
1766 } else {
1767 reg_index = dec_insn.arg_[i];
1768 }
1769
1770 llvm::Value* reg_value;
1771 if (klass->IsPrimitiveInt()) {
1772 reg_value = EmitLoadDalvikReg(reg_index, kInt, kAccurate);
1773 } else {
1774 reg_value = EmitLoadDalvikReg(reg_index, kObject, kAccurate);
1775 }
1776
1777 irb_.CreateStore(reg_value, data_field_addr);
1778
1779 data_field_addr_int = irb_.CreateAdd(data_field_addr_int, word_size);
1780 }
1781 }
1782
1783 EmitStoreDalvikRetValReg(kObject, kAccurate, object_addr);
1784
Logan Chien70f94b42011-12-27 17:49:11 +08001785 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1786}
1787
1788
1789void MethodCompiler::EmitInsn_FillArrayData(uint32_t dex_pc,
1790 Instruction const* insn) {
Logan Chiene58b6582012-01-16 17:13:13 +08001791
1792 Instruction::DecodedInstruction dec_insn(insn);
1793
1794 // Read the payload
1795 struct PACKED Payload {
1796 uint16_t ident_;
1797 uint16_t elem_width_;
1798 uint32_t num_elems_;
1799 uint8_t data_[];
1800 };
1801
1802 int32_t payload_offset = static_cast<int32_t>(dex_pc) +
1803 static_cast<int32_t>(dec_insn.vB_);
1804
1805 Payload const* payload =
1806 reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
1807
1808 uint32_t size_in_bytes = payload->elem_width_ * payload->num_elems_;
1809
1810 // Load and check the array
1811 llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1812
1813 EmitGuard_NullPointerException(dex_pc, array_addr);
1814
1815 if (payload->num_elems_ > 0) {
1816 // Test: Is array length big enough?
1817 llvm::Constant* last_index = irb_.getJInt(payload->num_elems_ - 1);
1818
1819 EmitGuard_ArrayIndexOutOfBoundsException(dex_pc, array_addr, last_index);
1820
1821 // Get array data field
1822 llvm::Value* data_field_offset_value =
1823 irb_.getPtrEquivInt(Array::DataOffset().Int32Value());
1824
1825 llvm::Value* data_field_addr =
1826 irb_.CreatePtrDisp(array_addr, data_field_offset_value,
1827 irb_.getInt8Ty()->getPointerTo());
1828
1829 // Emit payload to bitcode constant pool
1830 std::vector<llvm::Constant*> const_pool_data;
1831 for (uint32_t i = 0; i < size_in_bytes; ++i) {
1832 const_pool_data.push_back(irb_.getInt8(payload->data_[i]));
1833 }
1834
1835 llvm::Constant* const_pool_data_array_value = llvm::ConstantArray::get(
1836 llvm::ArrayType::get(irb_.getInt8Ty(), size_in_bytes), const_pool_data);
1837
1838 llvm::Value* const_pool_data_array_addr =
1839 new llvm::GlobalVariable(*module_,
1840 const_pool_data_array_value->getType(),
1841 false, llvm::GlobalVariable::InternalLinkage,
1842 const_pool_data_array_value,
1843 "array_data_payload");
1844
1845 // Find the memcpy intrinsic
1846 llvm::Type* memcpy_arg_types[] = {
1847 llvm::Type::getInt8Ty(*context_)->getPointerTo(),
1848 llvm::Type::getInt8Ty(*context_)->getPointerTo(),
1849 llvm::Type::getInt32Ty(*context_)
1850 };
1851
1852 llvm::Function* memcpy_intrinsic =
1853 llvm::Intrinsic::getDeclaration(module_,
1854 llvm::Intrinsic::memcpy,
1855 memcpy_arg_types);
1856
1857 // Copy now!
1858 llvm::Value *args[] = {
1859 data_field_addr,
1860 irb_.CreateConstGEP2_32(const_pool_data_array_addr, 0, 0),
1861 irb_.getInt32(size_in_bytes),
1862 irb_.getInt32(0), // alignment: no guarantee
1863 irb_.getFalse() // is_volatile: false
1864 };
1865
1866 irb_.CreateCall(memcpy_intrinsic, args);
1867 }
1868
Logan Chien70f94b42011-12-27 17:49:11 +08001869 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1870}
1871
1872
1873void MethodCompiler::EmitInsn_UnconditionalBranch(uint32_t dex_pc,
1874 Instruction const* insn) {
Logan Chiena466c162011-12-27 17:55:46 +08001875
1876 Instruction::DecodedInstruction dec_insn(insn);
1877
1878 int32_t branch_offset = dec_insn.vA_;
1879
1880 if (branch_offset <= 0) {
1881 // Garbage collection safe-point on backward branch
1882 EmitGuard_GarbageCollectionSuspend(dex_pc);
1883 }
1884
1885 irb_.CreateBr(GetBasicBlock(dex_pc + branch_offset));
Logan Chien70f94b42011-12-27 17:49:11 +08001886}
1887
1888
1889void MethodCompiler::EmitInsn_PackedSwitch(uint32_t dex_pc,
1890 Instruction const* insn) {
Logan Chien7a89b6d2011-12-27 17:56:56 +08001891
1892 Instruction::DecodedInstruction dec_insn(insn);
1893
1894 struct PACKED Payload {
1895 uint16_t ident_;
1896 uint16_t num_cases_;
1897 int32_t first_key_;
1898 int32_t targets_[];
1899 };
1900
1901 int32_t payload_offset = static_cast<int32_t>(dex_pc) +
1902 static_cast<int32_t>(dec_insn.vB_);
1903
1904 Payload const* payload =
1905 reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
1906
1907 llvm::Value* value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
1908
1909 llvm::SwitchInst* sw =
1910 irb_.CreateSwitch(value, GetNextBasicBlock(dex_pc), payload->num_cases_);
1911
1912 for (uint16_t i = 0; i < payload->num_cases_; ++i) {
1913 sw->addCase(irb_.getInt32(payload->first_key_ + i),
1914 GetBasicBlock(dex_pc + payload->targets_[i]));
1915 }
Logan Chien70f94b42011-12-27 17:49:11 +08001916}
1917
1918
1919void MethodCompiler::EmitInsn_SparseSwitch(uint32_t dex_pc,
1920 Instruction const* insn) {
Logan Chien7a89b6d2011-12-27 17:56:56 +08001921
1922 Instruction::DecodedInstruction dec_insn(insn);
1923
1924 struct PACKED Payload {
1925 uint16_t ident_;
1926 uint16_t num_cases_;
1927 int32_t keys_and_targets_[];
1928 };
1929
1930 int32_t payload_offset = static_cast<int32_t>(dex_pc) +
1931 static_cast<int32_t>(dec_insn.vB_);
1932
1933 Payload const* payload =
1934 reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
1935
1936 int32_t const* keys = payload->keys_and_targets_;
1937 int32_t const* targets = payload->keys_and_targets_ + payload->num_cases_;
1938
1939 llvm::Value* value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
1940
1941 llvm::SwitchInst* sw =
1942 irb_.CreateSwitch(value, GetNextBasicBlock(dex_pc), payload->num_cases_);
1943
1944 for (size_t i = 0; i < payload->num_cases_; ++i) {
1945 sw->addCase(irb_.getInt32(keys[i]), GetBasicBlock(dex_pc + targets[i]));
1946 }
Logan Chien70f94b42011-12-27 17:49:11 +08001947}
1948
1949
1950void MethodCompiler::EmitInsn_FPCompare(uint32_t dex_pc,
1951 Instruction const* insn,
1952 JType fp_jty,
1953 bool gt_bias) {
Logan Chien2c37e8e2011-12-27 17:58:46 +08001954
1955 Instruction::DecodedInstruction dec_insn(insn);
1956
1957 DCHECK(fp_jty == kFloat || fp_jty == kDouble) << "JType: " << fp_jty;
1958
1959 llvm::Value* src1_value = EmitLoadDalvikReg(dec_insn.vB_, fp_jty, kAccurate);
1960 llvm::Value* src2_value = EmitLoadDalvikReg(dec_insn.vC_, fp_jty, kAccurate);
1961
1962 llvm::Value* cmp_eq = irb_.CreateFCmpOEQ(src1_value, src2_value);
1963 llvm::Value* cmp_lt;
1964
1965 if (gt_bias) {
1966 cmp_lt = irb_.CreateFCmpOLT(src1_value, src2_value);
1967 } else {
1968 cmp_lt = irb_.CreateFCmpULT(src1_value, src2_value);
1969 }
1970
1971 llvm::Value* result = EmitCompareResultSelection(cmp_eq, cmp_lt);
1972 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
1973
Logan Chien70f94b42011-12-27 17:49:11 +08001974 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1975}
1976
1977
1978void MethodCompiler::EmitInsn_LongCompare(uint32_t dex_pc,
1979 Instruction const* insn) {
Logan Chien2c37e8e2011-12-27 17:58:46 +08001980
1981 Instruction::DecodedInstruction dec_insn(insn);
1982
1983 llvm::Value* src1_value = EmitLoadDalvikReg(dec_insn.vB_, kLong, kAccurate);
1984 llvm::Value* src2_value = EmitLoadDalvikReg(dec_insn.vC_, kLong, kAccurate);
1985
1986 llvm::Value* cmp_eq = irb_.CreateICmpEQ(src1_value, src2_value);
1987 llvm::Value* cmp_lt = irb_.CreateICmpSLT(src1_value, src2_value);
1988
1989 llvm::Value* result = EmitCompareResultSelection(cmp_eq, cmp_lt);
1990 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
1991
Logan Chien70f94b42011-12-27 17:49:11 +08001992 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1993}
1994
1995
Logan Chien2c37e8e2011-12-27 17:58:46 +08001996llvm::Value* MethodCompiler::EmitCompareResultSelection(llvm::Value* cmp_eq,
1997 llvm::Value* cmp_lt) {
1998
1999 llvm::Constant* zero = irb_.getJInt(0);
2000 llvm::Constant* pos1 = irb_.getJInt(1);
2001 llvm::Constant* neg1 = irb_.getJInt(-1);
2002
2003 llvm::Value* result_lt = irb_.CreateSelect(cmp_lt, neg1, pos1);
2004 llvm::Value* result_eq = irb_.CreateSelect(cmp_eq, zero, result_lt);
2005
2006 return result_eq;
2007}
2008
2009
Logan Chien70f94b42011-12-27 17:49:11 +08002010void MethodCompiler::EmitInsn_BinaryConditionalBranch(uint32_t dex_pc,
2011 Instruction const* insn,
2012 CondBranchKind cond) {
Logan Chiena78e3c82011-12-27 17:59:35 +08002013
2014 Instruction::DecodedInstruction dec_insn(insn);
2015
2016 int8_t src1_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA_);
2017 int8_t src2_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vB_);
2018
2019 DCHECK_NE(kRegUnknown, src1_reg_cat);
2020 DCHECK_NE(kRegUnknown, src2_reg_cat);
2021 DCHECK_NE(kRegCat2, src1_reg_cat);
2022 DCHECK_NE(kRegCat2, src2_reg_cat);
2023
2024 int32_t branch_offset = dec_insn.vC_;
2025
2026 if (branch_offset <= 0) {
2027 // Garbage collection safe-point on backward branch
2028 EmitGuard_GarbageCollectionSuspend(dex_pc);
2029 }
2030
2031 if (src1_reg_cat == kRegZero && src2_reg_cat == kRegZero) {
2032 irb_.CreateBr(GetBasicBlock(dex_pc + branch_offset));
2033 return;
2034 }
2035
2036 llvm::Value* src1_value;
2037 llvm::Value* src2_value;
2038
2039 if (src1_reg_cat != kRegZero && src2_reg_cat != kRegZero) {
2040 CHECK_EQ(src1_reg_cat, src2_reg_cat);
2041
2042 if (src1_reg_cat == kRegCat1nr) {
2043 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
2044 src2_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
2045 } else {
2046 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
2047 src2_value = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
2048 }
2049 } else {
2050 DCHECK(src1_reg_cat == kRegZero ||
2051 src2_reg_cat == kRegZero);
2052
2053 if (src1_reg_cat == kRegZero) {
2054 if (src2_reg_cat == kRegCat1nr) {
2055 src1_value = irb_.getJInt(0);
2056 src2_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
2057 } else {
2058 src1_value = irb_.getJNull();
2059 src2_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
2060 }
2061 } else { // src2_reg_cat == kRegZero
2062 if (src2_reg_cat == kRegCat1nr) {
2063 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
2064 src2_value = irb_.getJInt(0);
2065 } else {
2066 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
2067 src2_value = irb_.getJNull();
2068 }
2069 }
2070 }
2071
2072 llvm::Value* cond_value =
2073 EmitConditionResult(src1_value, src2_value, cond);
2074
2075 irb_.CreateCondBr(cond_value,
2076 GetBasicBlock(dex_pc + branch_offset),
2077 GetNextBasicBlock(dex_pc));
Logan Chien70f94b42011-12-27 17:49:11 +08002078}
2079
2080
2081void MethodCompiler::EmitInsn_UnaryConditionalBranch(uint32_t dex_pc,
2082 Instruction const* insn,
2083 CondBranchKind cond) {
Logan Chiena78e3c82011-12-27 17:59:35 +08002084
2085 Instruction::DecodedInstruction dec_insn(insn);
2086
2087 int8_t src_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA_);
2088
2089 DCHECK_NE(kRegUnknown, src_reg_cat);
2090 DCHECK_NE(kRegCat2, src_reg_cat);
2091
2092 int32_t branch_offset = dec_insn.vB_;
2093
2094 if (branch_offset <= 0) {
2095 // Garbage collection safe-point on backward branch
2096 EmitGuard_GarbageCollectionSuspend(dex_pc);
2097 }
2098
2099 if (src_reg_cat == kRegZero) {
2100 irb_.CreateBr(GetBasicBlock(dex_pc + branch_offset));
2101 return;
2102 }
2103
2104 llvm::Value* src1_value;
2105 llvm::Value* src2_value;
2106
2107 if (src_reg_cat == kRegCat1nr) {
2108 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
2109 src2_value = irb_.getInt32(0);
2110 } else {
2111 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
2112 src2_value = irb_.getJNull();
2113 }
2114
2115 llvm::Value* cond_value =
2116 EmitConditionResult(src1_value, src2_value, cond);
2117
2118 irb_.CreateCondBr(cond_value,
2119 GetBasicBlock(dex_pc + branch_offset),
2120 GetNextBasicBlock(dex_pc));
2121}
2122
2123
2124RegCategory MethodCompiler::GetInferredRegCategory(uint32_t dex_pc,
2125 uint16_t reg_idx) {
2126 InferredRegCategoryMap const* map = method_->GetInferredRegCategoryMap();
2127 CHECK_NE(map, static_cast<InferredRegCategoryMap*>(NULL));
2128
2129 return map->GetRegCategory(dex_pc, reg_idx);
2130}
2131
2132
2133llvm::Value* MethodCompiler::EmitConditionResult(llvm::Value* lhs,
2134 llvm::Value* rhs,
2135 CondBranchKind cond) {
2136 switch (cond) {
2137 case kCondBranch_EQ:
2138 return irb_.CreateICmpEQ(lhs, rhs);
2139
2140 case kCondBranch_NE:
2141 return irb_.CreateICmpNE(lhs, rhs);
2142
2143 case kCondBranch_LT:
2144 return irb_.CreateICmpSLT(lhs, rhs);
2145
2146 case kCondBranch_GE:
2147 return irb_.CreateICmpSGE(lhs, rhs);
2148
2149 case kCondBranch_GT:
2150 return irb_.CreateICmpSGT(lhs, rhs);
2151
2152 case kCondBranch_LE:
2153 return irb_.CreateICmpSLE(lhs, rhs);
2154
2155 default: // Unreachable
2156 LOG(FATAL) << "Unknown conditional branch kind: " << cond;
2157 return NULL;
2158 }
Logan Chien70f94b42011-12-27 17:49:11 +08002159}
2160
2161
Logan Chiene27fdbb2012-01-02 23:27:26 +08002162void
2163MethodCompiler::EmitGuard_ArrayIndexOutOfBoundsException(uint32_t dex_pc,
2164 llvm::Value* array,
2165 llvm::Value* index) {
2166 llvm::Value* array_len = EmitLoadArrayLength(array);
2167
2168 llvm::Value* cmp = irb_.CreateICmpUGE(index, array_len);
2169
2170 llvm::BasicBlock* block_exception =
2171 CreateBasicBlockWithDexPC(dex_pc, "overflow");
2172
2173 llvm::BasicBlock* block_continue =
2174 CreateBasicBlockWithDexPC(dex_pc, "cont");
2175
2176 irb_.CreateCondBr(cmp, block_exception, block_continue);
2177
2178 irb_.SetInsertPoint(block_exception);
Logan Chien8dfcbea2012-02-17 18:50:32 +08002179
2180 EmitUpdateLineNumFromDexPC(dex_pc);
Logan Chiene27fdbb2012-01-02 23:27:26 +08002181 irb_.CreateCall2(irb_.GetRuntime(ThrowIndexOutOfBounds), index, array_len);
2182 EmitBranchExceptionLandingPad(dex_pc);
2183
2184 irb_.SetInsertPoint(block_continue);
2185}
2186
2187
2188void MethodCompiler::EmitGuard_ArrayException(uint32_t dex_pc,
2189 llvm::Value* array,
2190 llvm::Value* index) {
2191 EmitGuard_NullPointerException(dex_pc, array);
2192 EmitGuard_ArrayIndexOutOfBoundsException(dex_pc, array, index);
2193}
2194
2195
2196// Emit Array GetElementPtr
2197llvm::Value* MethodCompiler::EmitArrayGEP(llvm::Value* array_addr,
2198 llvm::Value* index_value,
2199 llvm::Type* elem_type) {
2200
2201 llvm::Constant* data_offset_value =
2202 irb_.getPtrEquivInt(Array::DataOffset().Int32Value());
2203
2204 llvm::Value* array_data_addr =
2205 irb_.CreatePtrDisp(array_addr, data_offset_value,
2206 elem_type->getPointerTo());
2207
2208 return irb_.CreateGEP(array_data_addr, index_value);
2209}
2210
2211
Logan Chien70f94b42011-12-27 17:49:11 +08002212void MethodCompiler::EmitInsn_AGet(uint32_t dex_pc,
2213 Instruction const* insn,
2214 JType elem_jty) {
Logan Chiene27fdbb2012-01-02 23:27:26 +08002215
2216 Instruction::DecodedInstruction dec_insn(insn);
2217
2218 llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
2219 llvm::Value* index_value = EmitLoadDalvikReg(dec_insn.vC_, kInt, kAccurate);
2220
2221 EmitGuard_ArrayException(dex_pc, array_addr, index_value);
2222
2223 llvm::Type* elem_type = irb_.getJType(elem_jty, kArray);
2224
2225 llvm::Value* array_elem_addr =
2226 EmitArrayGEP(array_addr, index_value, elem_type);
2227
2228 llvm::Value* array_elem_value = irb_.CreateLoad(array_elem_addr);
2229
2230 EmitStoreDalvikReg(dec_insn.vA_, elem_jty, kArray, array_elem_value);
2231
Logan Chien70f94b42011-12-27 17:49:11 +08002232 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2233}
2234
2235
2236void MethodCompiler::EmitInsn_APut(uint32_t dex_pc,
2237 Instruction const* insn,
2238 JType elem_jty) {
Logan Chien8dabb432012-01-02 23:29:32 +08002239
2240 Instruction::DecodedInstruction dec_insn(insn);
2241
2242 llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
2243 llvm::Value* index_value = EmitLoadDalvikReg(dec_insn.vC_, kInt, kAccurate);
2244
2245 EmitGuard_ArrayException(dex_pc, array_addr, index_value);
2246
2247 llvm::Type* elem_type = irb_.getJType(elem_jty, kArray);
2248
2249 llvm::Value* array_elem_addr =
2250 EmitArrayGEP(array_addr, index_value, elem_type);
2251
2252 llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, elem_jty, kArray);
2253
2254 irb_.CreateStore(new_value, array_elem_addr);
2255
Logan Chien70f94b42011-12-27 17:49:11 +08002256 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2257}
2258
2259
Logan Chien48f1d2a2012-01-02 22:49:53 +08002260void MethodCompiler::PrintUnresolvedFieldWarning(int32_t field_idx) {
2261 DexFile const& dex_file = method_helper_.GetDexFile();
2262 DexFile::FieldId const& field_id = dex_file.GetFieldId(field_idx);
2263
2264 LOG(WARNING) << "unable to resolve static field " << field_idx << " ("
2265 << dex_file.GetFieldName(field_id) << ") in "
2266 << dex_file.GetFieldDeclaringClassDescriptor(field_id);
2267}
2268
2269
Logan Chien70f94b42011-12-27 17:49:11 +08002270void MethodCompiler::EmitInsn_IGet(uint32_t dex_pc,
2271 Instruction const* insn,
2272 JType field_jty) {
Logan Chien48f1d2a2012-01-02 22:49:53 +08002273
2274 Instruction::DecodedInstruction dec_insn(insn);
2275
2276 uint32_t reg_idx = dec_insn.vB_;
2277 uint32_t field_idx = dec_insn.vC_;
2278
2279 Field* field = dex_cache_->GetResolvedField(field_idx);
2280
2281 llvm::Value* object_addr = EmitLoadDalvikReg(reg_idx, kObject, kAccurate);
2282
2283 EmitGuard_NullPointerException(dex_pc, object_addr);
2284
2285 llvm::Value* field_value;
2286
2287 if (field == NULL) {
2288 PrintUnresolvedFieldWarning(field_idx);
2289
2290 llvm::Function* runtime_func;
2291
2292 if (field_jty == kObject) {
2293 runtime_func = irb_.GetRuntime(SetObjectInstance);
2294 } else if (field_jty == kLong || field_jty == kDouble) {
2295 runtime_func = irb_.GetRuntime(Set64Instance);
2296 } else {
2297 runtime_func = irb_.GetRuntime(Set32Instance);
2298 }
2299
2300 llvm::ConstantInt* field_idx_value = irb_.getInt32(field_idx);
2301
2302 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2303
Logan Chien8dfcbea2012-02-17 18:50:32 +08002304 EmitUpdateLineNumFromDexPC(dex_pc);
2305
Logan Chien48f1d2a2012-01-02 22:49:53 +08002306 field_value = irb_.CreateCall2(runtime_func, field_idx_value,
2307 method_object_addr);
2308
2309 EmitGuard_ExceptionLandingPad(dex_pc);
2310
2311 } else {
2312 llvm::PointerType* field_type =
2313 irb_.getJType(field_jty, kField)->getPointerTo();
2314
2315 llvm::ConstantInt* field_offset =
2316 irb_.getPtrEquivInt(field->GetOffset().Int32Value());
2317
2318 llvm::Value* field_addr =
2319 irb_.CreatePtrDisp(object_addr, field_offset, field_type);
2320
2321 field_value = irb_.CreateLoad(field_addr);
2322 }
2323
2324 EmitStoreDalvikReg(dec_insn.vA_, field_jty, kField, field_value);
2325
Logan Chien70f94b42011-12-27 17:49:11 +08002326 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2327}
2328
2329
2330void MethodCompiler::EmitInsn_IPut(uint32_t dex_pc,
2331 Instruction const* insn,
2332 JType field_jty) {
Logan Chiendd6aa872012-01-03 16:06:32 +08002333
2334 Instruction::DecodedInstruction dec_insn(insn);
2335
2336 uint32_t reg_idx = dec_insn.vB_;
2337 uint32_t field_idx = dec_insn.vC_;
2338
2339 Field* field = dex_cache_->GetResolvedField(field_idx);
2340
2341 llvm::Value* object_addr = EmitLoadDalvikReg(reg_idx, kObject, kAccurate);
2342
2343 EmitGuard_NullPointerException(dex_pc, object_addr);
2344
2345 llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, field_jty, kField);
2346
2347 if (field == NULL) {
2348 PrintUnresolvedFieldWarning(field_idx);
2349
2350 llvm::Function* runtime_func;
2351
2352 if (field_jty == kObject) {
2353 runtime_func = irb_.GetRuntime(SetObjectInstance);
2354 } else if (field_jty == kLong || field_jty == kDouble) {
2355 runtime_func = irb_.GetRuntime(Set64Instance);
2356 } else {
2357 runtime_func = irb_.GetRuntime(Set32Instance);
2358 }
2359
2360 llvm::Value* field_idx_value = irb_.getInt32(field_idx);
2361
2362 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2363
Logan Chien8dfcbea2012-02-17 18:50:32 +08002364 EmitUpdateLineNumFromDexPC(dex_pc);
2365
Logan Chiendd6aa872012-01-03 16:06:32 +08002366 irb_.CreateCall3(runtime_func, field_idx_value,
2367 method_object_addr, new_value);
2368
2369 EmitGuard_ExceptionLandingPad(dex_pc);
2370
2371 } else {
2372 llvm::PointerType* field_type =
2373 irb_.getJType(field_jty, kField)->getPointerTo();
2374
2375 llvm::Value* field_offset =
2376 irb_.getPtrEquivInt(field->GetOffset().Int32Value());
2377
2378 llvm::Value* field_addr =
2379 irb_.CreatePtrDisp(object_addr, field_offset, field_type);
2380
2381 irb_.CreateStore(new_value, field_addr);
2382 }
2383
Logan Chien70f94b42011-12-27 17:49:11 +08002384 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2385}
2386
2387
Logan Chien2aeca0b2012-02-03 22:55:46 +08002388Method* MethodCompiler::ResolveMethod(uint32_t method_idx) {
2389 Thread* thread = Thread::Current();
2390
2391 // Save the exception state
2392 Throwable* old_exception = NULL;
2393 if (thread->IsExceptionPending()) {
2394 old_exception = thread->GetException();
2395 thread->ClearException();
2396 }
2397
2398 // Resolve the method through the class linker
2399 Method* method = class_linker_->ResolveMethod(*dex_file_, method_idx,
2400 dex_cache_, class_loader_,
2401 /* is_direct= */ false);
2402
2403 if (method == NULL) {
2404 // Ignore the exception raised during the method resolution
2405 thread->ClearException();
2406 }
2407
2408 // Restore the exception state
2409 if (old_exception != NULL) {
2410 thread->SetException(old_exception);
2411 }
2412
2413 return method;
2414}
2415
2416
Logan Chien438c4b62012-01-17 16:06:00 +08002417Field* MethodCompiler::ResolveField(uint32_t field_idx) {
2418 Thread* thread = Thread::Current();
2419
2420 // Save the exception state
2421 Throwable* old_exception = NULL;
2422 if (thread->IsExceptionPending()) {
2423 old_exception = thread->GetException();
2424 thread->ClearException();
2425 }
2426
2427 // Resolve the fields through the class linker
2428 Field* field = class_linker_->ResolveField(*dex_file_, field_idx,
2429 dex_cache_, class_loader_,
2430 /* is_static= */ true);
2431
2432 if (field == NULL) {
2433 // Ignore the exception raised during the field resolution
2434 thread->ClearException();
2435 }
2436
2437 // Restore the exception state
2438 if (old_exception != NULL) {
2439 thread->SetException(old_exception);
2440 }
2441
2442 return field;
2443}
2444
2445
2446Field* MethodCompiler::
2447FindFieldAndDeclaringTypeIdx(uint32_t field_idx,
2448 uint32_t &resolved_type_idx) {
2449
2450 // Resolve the field through the class linker
2451 Field* field = ResolveField(field_idx);
2452 if (field == NULL) {
2453 return NULL;
2454 }
2455
2456 DexFile::FieldId const& field_id = dex_file_->GetFieldId(field_idx);
2457
2458 // Search for the type_idx of the declaring class
2459 uint16_t type_idx = field_id.class_idx_;
2460 Class* klass = dex_cache_->GetResolvedTypes()->Get(type_idx);
2461
2462 // Test: Is referring_class equal to declaring_class?
2463
2464 // If true, then return the type_idx; otherwise, this field must be declared
2465 // in super class or interfaces, we have to search for declaring class.
2466
2467 if (field->GetDeclaringClass() == klass) {
2468 resolved_type_idx = type_idx;
2469 return field;
2470 }
2471
2472 // Search for the type_idx of the super class or interfaces
2473 std::string desc(FieldHelper(field).GetDeclaringClassDescriptor());
2474
2475 DexFile::StringId const* string_id = dex_file_->FindStringId(desc);
2476
2477 if (string_id == NULL) {
2478 return NULL;
2479 }
2480
2481 DexFile::TypeId const* type_id =
2482 dex_file_->FindTypeId(dex_file_->GetIndexForStringId(*string_id));
2483
2484 if (type_id == NULL) {
2485 return NULL;
2486 }
2487
2488 resolved_type_idx = dex_file_->GetIndexForTypeId(*type_id);
2489 return field;
2490}
2491
2492
2493llvm::Value* MethodCompiler::EmitLoadStaticStorage(uint32_t dex_pc,
2494 uint32_t type_idx) {
2495 llvm::BasicBlock* block_load_static =
2496 CreateBasicBlockWithDexPC(dex_pc, "load_static");
2497
2498 llvm::BasicBlock* block_cont = CreateBasicBlockWithDexPC(dex_pc, "cont");
2499
2500 // Load static storage from dex cache
2501 llvm::Value* storage_field_addr =
2502 EmitLoadDexCacheStaticStorageFieldAddr(type_idx);
2503
2504 llvm::Value* storage_object_addr = irb_.CreateLoad(storage_field_addr);
2505
2506 llvm::BasicBlock* block_original = irb_.GetInsertBlock();
2507
2508 // Test: Is the static storage of this class initialized?
2509 llvm::Value* equal_null =
2510 irb_.CreateICmpEQ(storage_object_addr, irb_.getJNull());
2511
2512 irb_.CreateCondBr(equal_null, block_load_static, block_cont);
2513
2514 // Failback routine to load the class object
2515 irb_.SetInsertPoint(block_load_static);
2516
2517 llvm::Function* runtime_func =
2518 irb_.GetRuntime(InitializeStaticStorage);
2519
2520 llvm::Constant* type_idx_value = irb_.getInt32(type_idx);
2521
2522 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2523
Logan Chien8dfcbea2012-02-17 18:50:32 +08002524 EmitUpdateLineNumFromDexPC(dex_pc);
2525
Logan Chien438c4b62012-01-17 16:06:00 +08002526 llvm::Value* loaded_storage_object_addr =
2527 irb_.CreateCall2(runtime_func, type_idx_value, method_object_addr);
2528
2529 EmitGuard_ExceptionLandingPad(dex_pc);
2530
2531 llvm::BasicBlock* block_after_load_static = irb_.GetInsertBlock();
2532
2533 irb_.CreateBr(block_cont);
2534
2535 // Now the class object must be loaded
2536 irb_.SetInsertPoint(block_cont);
2537
2538 llvm::PHINode* phi = irb_.CreatePHI(irb_.getJObjectTy(), 2);
2539
2540 phi->addIncoming(storage_object_addr, block_original);
2541 phi->addIncoming(loaded_storage_object_addr, block_after_load_static);
2542
2543 return phi;
2544}
2545
2546
Logan Chien70f94b42011-12-27 17:49:11 +08002547void MethodCompiler::EmitInsn_SGet(uint32_t dex_pc,
2548 Instruction const* insn,
2549 JType field_jty) {
Logan Chien438c4b62012-01-17 16:06:00 +08002550
2551 Instruction::DecodedInstruction dec_insn(insn);
2552
2553 uint32_t declaring_type_idx = DexFile::kDexNoIndex;
2554
2555 Field* field = FindFieldAndDeclaringTypeIdx(dec_insn.vB_, declaring_type_idx);
2556
2557 llvm::Value* static_field_value;
2558
2559 if (field == NULL) {
2560 llvm::Function* runtime_func;
2561
2562 if (field_jty == kObject) {
2563 runtime_func = irb_.GetRuntime(GetObjectStatic);
2564 } else if (field_jty == kLong || field_jty == kDouble) {
2565 runtime_func = irb_.GetRuntime(Get64Static);
2566 } else {
2567 runtime_func = irb_.GetRuntime(Get32Static);
2568 }
2569
2570 llvm::Constant* field_idx_value = irb_.getInt32(dec_insn.vB_);
2571
2572 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2573
Logan Chien8dfcbea2012-02-17 18:50:32 +08002574 EmitUpdateLineNumFromDexPC(dex_pc);
2575
Logan Chien438c4b62012-01-17 16:06:00 +08002576 static_field_value =
2577 irb_.CreateCall2(runtime_func, field_idx_value, method_object_addr);
2578
2579 EmitGuard_ExceptionLandingPad(dex_pc);
2580
2581 } else {
2582 llvm::Value* static_storage_addr =
2583 EmitLoadStaticStorage(dex_pc, declaring_type_idx);
2584
2585 llvm::Value* static_field_offset_value =
2586 irb_.getPtrEquivInt(field->GetOffset().Int32Value());
2587
2588 llvm::Value* static_field_addr =
2589 irb_.CreatePtrDisp(static_storage_addr, static_field_offset_value,
2590 irb_.getJType(field_jty, kField)->getPointerTo());
2591
2592 static_field_value = irb_.CreateLoad(static_field_addr);
2593 }
2594
2595 EmitStoreDalvikReg(dec_insn.vA_, field_jty, kField, static_field_value);
2596
Logan Chien70f94b42011-12-27 17:49:11 +08002597 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2598}
2599
2600
2601void MethodCompiler::EmitInsn_SPut(uint32_t dex_pc,
2602 Instruction const* insn,
2603 JType field_jty) {
Logan Chien14179c82012-01-17 17:06:34 +08002604
2605 Instruction::DecodedInstruction dec_insn(insn);
2606
2607 uint32_t declaring_type_idx = DexFile::kDexNoIndex;
2608
2609 Field* field = FindFieldAndDeclaringTypeIdx(dec_insn.vB_, declaring_type_idx);
2610
2611 llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, field_jty, kField);
2612
2613 if (field == NULL) {
2614 llvm::Function* runtime_func;
2615
2616 if (field_jty == kObject) {
2617 runtime_func = irb_.GetRuntime(SetObjectStatic);
2618 } else if (field_jty == kLong || field_jty == kDouble) {
2619 runtime_func = irb_.GetRuntime(Set64Static);
2620 } else {
2621 runtime_func = irb_.GetRuntime(Set32Static);
2622 }
2623
2624 llvm::Constant* field_idx_value = irb_.getInt32(dec_insn.vB_);
2625
2626 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2627
Logan Chien8dfcbea2012-02-17 18:50:32 +08002628 EmitUpdateLineNumFromDexPC(dex_pc);
2629
Logan Chien14179c82012-01-17 17:06:34 +08002630 irb_.CreateCall3(runtime_func, field_idx_value,
2631 method_object_addr, new_value);
2632
2633 EmitGuard_ExceptionLandingPad(dex_pc);
2634
2635 } else {
2636 llvm::Value* static_storage_addr =
2637 EmitLoadStaticStorage(dex_pc, declaring_type_idx);
2638
2639 llvm::Value* static_field_offset_value =
2640 irb_.getPtrEquivInt(field->GetOffset().Int32Value());
2641
2642 llvm::Value* static_field_addr =
2643 irb_.CreatePtrDisp(static_storage_addr, static_field_offset_value,
2644 irb_.getJType(field_jty, kField)->getPointerTo());
2645
2646 irb_.CreateStore(new_value, static_field_addr);
2647 }
2648
Logan Chien70f94b42011-12-27 17:49:11 +08002649 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2650}
2651
2652
Logan Chien1a121b92012-02-15 22:23:42 +08002653llvm::Value* MethodCompiler::
2654EmitLoadCalleeThis(Instruction::DecodedInstruction const& dec_insn,
2655 bool is_range) {
2656 if (is_range) {
2657 return EmitLoadDalvikReg(dec_insn.vC_, kObject, kAccurate);
2658 } else {
2659 return EmitLoadDalvikReg(dec_insn.arg_[0], kObject, kAccurate);
2660 }
2661}
2662
2663
2664void MethodCompiler::
2665EmitLoadActualParameters(std::vector<llvm::Value*>& args,
2666 uint32_t callee_method_idx,
2667 Instruction::DecodedInstruction const& dec_insn,
2668 bool is_range,
2669 bool is_static) {
2670
2671 // Get method signature
2672 DexFile::MethodId const& method_id =
2673 dex_file_->GetMethodId(callee_method_idx);
2674
Logan Chien8faf8022012-02-24 12:25:29 +08002675 uint32_t shorty_size;
Logan Chien1a121b92012-02-15 22:23:42 +08002676 char const* shorty = dex_file_->GetMethodShorty(method_id, &shorty_size);
Logan Chien8faf8022012-02-24 12:25:29 +08002677 CHECK_GE(shorty_size, 1u);
Logan Chien1a121b92012-02-15 22:23:42 +08002678
2679 // Load argument values according to the shorty (without "this")
2680 uint16_t reg_count = 0;
2681
2682 if (!is_static) {
2683 ++reg_count; // skip the "this" pointer
2684 }
2685
Logan Chien8faf8022012-02-24 12:25:29 +08002686 for (uint32_t i = 1; i < shorty_size; ++i) {
Logan Chien1a121b92012-02-15 22:23:42 +08002687 uint32_t reg_idx = (is_range) ? (dec_insn.vC_ + reg_count)
2688 : (dec_insn.arg_[reg_count]);
2689
2690 args.push_back(EmitLoadDalvikReg(reg_idx, shorty[i], kAccurate));
2691
2692 ++reg_count;
2693 if (shorty[i] == 'J' || shorty[i] == 'D') {
2694 // Wide types, such as long and double, are using a pair of registers
2695 // to store the value, so we have to increase arg_reg again.
2696 ++reg_count;
2697 }
2698 }
2699
2700 DCHECK_EQ(reg_count, dec_insn.vA_)
2701 << "Actual argument mismatch for callee: "
2702 << PrettyMethod(callee_method_idx, *dex_file_);
2703}
2704
2705
2706
Logan Chien70f94b42011-12-27 17:49:11 +08002707void MethodCompiler::EmitInsn_InvokeVirtual(uint32_t dex_pc,
2708 Instruction const* insn,
2709 bool is_range) {
Logan Chien46fbb412012-02-15 22:29:08 +08002710
2711 Instruction::DecodedInstruction dec_insn(insn);
2712
2713 uint32_t callee_method_idx = dec_insn.vB_;
2714
2715 // Find the method object at compile time
2716 Method* callee_method = ResolveMethod(callee_method_idx);
2717
2718 if (callee_method == NULL) {
2719 // Callee method can't be resolved at compile time. Emit the runtime
2720 // method resolution code.
2721
2722 UNIMPLEMENTED(FATAL) << "Method index " << callee_method_idx
2723 << " can't be resolved";
2724
2725 } else {
2726 // Test: Is *this* parameter equal to null?
2727 llvm::Value* this_addr = EmitLoadCalleeThis(dec_insn, is_range);
2728 EmitGuard_NullPointerException(dex_pc, this_addr);
2729
2730 // Load class object of *this* pointer
2731 llvm::Value* class_object_addr = EmitLoadClassObjectAddr(this_addr);
2732
2733 // Load callee method code address (branch destination)
2734 llvm::Value* vtable_addr = EmitLoadVTableAddr(class_object_addr);
2735
2736 llvm::Value* method_object_addr =
2737 EmitLoadMethodObjectAddrFromVTable(vtable_addr,
2738 callee_method->GetMethodIndex());
2739
2740 llvm::Value* code_addr =
2741 EmitLoadCodeAddr(method_object_addr, callee_method_idx, false);
2742
2743 // Load actual parameters
2744 std::vector<llvm::Value*> args;
2745 args.push_back(method_object_addr);
2746 args.push_back(this_addr);
2747 EmitLoadActualParameters(args, callee_method_idx, dec_insn,
2748 is_range, false);
2749
2750 // Invoke callee
Logan Chien8dfcbea2012-02-17 18:50:32 +08002751 EmitUpdateLineNumFromDexPC(dex_pc);
Logan Chien46fbb412012-02-15 22:29:08 +08002752 llvm::Value* retval = irb_.CreateCall(code_addr, args);
Logan Chien46fbb412012-02-15 22:29:08 +08002753 EmitGuard_ExceptionLandingPad(dex_pc);
2754
2755 MethodHelper method_helper(callee_method);
2756 char ret_shorty = method_helper.GetShorty()[0];
2757 if (ret_shorty != 'V') {
2758 EmitStoreDalvikRetValReg(ret_shorty, kAccurate, retval);
2759 }
2760 }
2761
Logan Chien70f94b42011-12-27 17:49:11 +08002762 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2763}
2764
2765
2766void MethodCompiler::EmitInsn_InvokeSuper(uint32_t dex_pc,
2767 Instruction const* insn,
2768 bool is_range) {
Logan Chiene73b6212012-01-27 01:47:29 +08002769
2770 Instruction::DecodedInstruction dec_insn(insn);
2771
2772 uint32_t callee_method_idx = dec_insn.vB_;
2773
2774 // Find the method object at compile time
2775 Method* callee_overiding_method = ResolveMethod(callee_method_idx);
2776
2777 if (callee_overiding_method == NULL) {
2778 // Callee method can't be resolved at compile time. Emit the runtime
2779 // method resolution code.
2780
2781 UNIMPLEMENTED(FATAL) << "Method index " << callee_method_idx
2782 << " can't be resolved";
2783
2784 } else {
2785 // CHECK: Is the instruction well-encoded or is the class hierarchy correct?
2786 Class* declaring_class = method_->GetDeclaringClass();
2787 CHECK_NE(declaring_class, static_cast<Class*>(NULL));
2788
2789 Class* super_class = declaring_class->GetSuperClass();
2790 CHECK_NE(super_class, static_cast<Class*>(NULL));
2791
2792 uint16_t callee_method_index = callee_overiding_method->GetMethodIndex();
2793 CHECK_GT(super_class->GetVTable()->GetLength(), callee_method_index);
2794
2795 Method* callee_method = super_class->GetVTable()->Get(callee_method_index);
2796 CHECK_NE(callee_method, static_cast<Method*>(NULL));
2797
2798 // Test: Is *this* parameter equal to null?
2799 llvm::Value* this_addr = EmitLoadCalleeThis(dec_insn, is_range);
2800 EmitGuard_NullPointerException(dex_pc, this_addr);
2801
2802 // Load declaring class of the caller method
2803 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2804
2805 llvm::ConstantInt* declaring_class_offset_value =
2806 irb_.getPtrEquivInt(Method::DeclaringClassOffset().Int32Value());
2807
2808 llvm::Value* declaring_class_field_addr =
2809 irb_.CreatePtrDisp(method_object_addr, declaring_class_offset_value,
2810 irb_.getJObjectTy()->getPointerTo());
2811
2812 llvm::Value* declaring_class_addr =
2813 irb_.CreateLoad(declaring_class_field_addr);
2814
2815 // Load the super class of the declaring class
2816 llvm::Value* super_class_offset_value =
2817 irb_.getPtrEquivInt(Class::SuperClassOffset().Int32Value());
2818
2819 llvm::Value* super_class_field_addr =
2820 irb_.CreatePtrDisp(declaring_class_addr, super_class_offset_value,
2821 irb_.getJObjectTy()->getPointerTo());
2822
2823 llvm::Value* super_class_addr =
2824 irb_.CreateLoad(super_class_field_addr);
2825
2826 // Load method object from virtual table
2827 llvm::Value* vtable_addr = EmitLoadVTableAddr(super_class_addr);
2828
2829 llvm::Value* callee_method_object_addr =
2830 EmitLoadMethodObjectAddrFromVTable(vtable_addr,
2831 callee_method->GetMethodIndex());
2832
2833 llvm::Value* code_addr =
2834 EmitLoadCodeAddr(callee_method_object_addr,
2835 callee_method_idx, false);
2836
2837 // Load actual parameters
2838 std::vector<llvm::Value*> args;
2839 args.push_back(callee_method_object_addr);
2840 args.push_back(this_addr);
2841 EmitLoadActualParameters(args, callee_method_idx, dec_insn,
2842 is_range, false);
2843
2844 // Invoke callee
Logan Chien8dfcbea2012-02-17 18:50:32 +08002845 EmitUpdateLineNumFromDexPC(dex_pc);
Logan Chiene73b6212012-01-27 01:47:29 +08002846 llvm::Value* retval = irb_.CreateCall(code_addr, args);
Logan Chiene73b6212012-01-27 01:47:29 +08002847 EmitGuard_ExceptionLandingPad(dex_pc);
2848
2849 MethodHelper method_helper(callee_method);
2850 char ret_shorty = method_helper.GetShorty()[0];
2851 if (ret_shorty != 'V') {
2852 EmitStoreDalvikRetValReg(ret_shorty, kAccurate, retval);
2853 }
2854 }
2855
Logan Chien70f94b42011-12-27 17:49:11 +08002856 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2857}
2858
2859
Logan Chien1a121b92012-02-15 22:23:42 +08002860void MethodCompiler::EmitInsn_InvokeStaticDirect(uint32_t dex_pc,
2861 Instruction const* insn,
Logan Chien61c65dc2012-02-29 03:22:30 +08002862 InvokeType invoke_type,
2863 bool is_range) {
Logan Chien70f94b42011-12-27 17:49:11 +08002864
Logan Chien1a121b92012-02-15 22:23:42 +08002865 Instruction::DecodedInstruction dec_insn(insn);
Logan Chien70f94b42011-12-27 17:49:11 +08002866
Logan Chien1a121b92012-02-15 22:23:42 +08002867 uint32_t callee_method_idx = dec_insn.vB_;
2868
Logan Chien61c65dc2012-02-29 03:22:30 +08002869 bool is_static = (invoke_type == kStatic);
2870
2871 UniquePtr<OatCompilationUnit> callee_oatcompilation_unit(
2872 oatcompilation_unit_->GetCallee(callee_method_idx, is_static ? kAccStatic : 0));
2873
2874 int vtable_idx = -1; // Currently unused
2875 bool is_fast_path = compiler_->
2876 ComputeInvokeInfo(callee_method_idx, callee_oatcompilation_unit.get(),
2877 invoke_type, vtable_idx);
2878
2879 CHECK(is_fast_path) << "Slow path for invoke static/direct is unimplemented";
Logan Chien1a121b92012-02-15 22:23:42 +08002880
2881 llvm::Value* this_addr = NULL;
2882
2883 if (!is_static) {
2884 // Test: Is *this* parameter equal to null?
2885 this_addr = EmitLoadCalleeThis(dec_insn, is_range);
2886 EmitGuard_NullPointerException(dex_pc, this_addr);
2887 }
2888
2889 // Load method function pointers
Logan Chien61c65dc2012-02-29 03:22:30 +08002890 llvm::Value* callee_method_object_field_addr =
2891 EmitLoadDexCacheResolvedMethodFieldAddr(callee_method_idx);
Logan Chien1a121b92012-02-15 22:23:42 +08002892
2893 llvm::Value* callee_method_object_addr =
Logan Chien61c65dc2012-02-29 03:22:30 +08002894 irb_.CreateLoad(callee_method_object_field_addr);
2895
2896 llvm::Value* code_addr =
2897 EmitLoadCodeAddr(callee_method_object_addr, callee_method_idx, is_static);
Logan Chien1a121b92012-02-15 22:23:42 +08002898
2899 // Load the actual parameter
2900 std::vector<llvm::Value*> args;
2901
2902 args.push_back(callee_method_object_addr); // method object for callee
2903
2904 if (!is_static) {
2905 args.push_back(this_addr); // "this" object for callee
2906 }
2907
2908 EmitLoadActualParameters(args, callee_method_idx, dec_insn,
2909 is_range, is_static);
2910
Logan Chien8dfcbea2012-02-17 18:50:32 +08002911 // Invoke callee
2912 EmitUpdateLineNumFromDexPC(dex_pc);
Logan Chien1a121b92012-02-15 22:23:42 +08002913 llvm::Value* retval = irb_.CreateCall(code_addr, args);
2914 EmitGuard_ExceptionLandingPad(dex_pc);
2915
Logan Chien61c65dc2012-02-29 03:22:30 +08002916 char ret_shorty = callee_oatcompilation_unit->GetShorty()[0];
Shih-wei Liao90d50992012-02-19 03:32:05 -08002917 if (ret_shorty != 'V') {
Logan Chien1a121b92012-02-15 22:23:42 +08002918 EmitStoreDalvikRetValReg(ret_shorty, kAccurate, retval);
2919 }
2920
Logan Chien70f94b42011-12-27 17:49:11 +08002921 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2922}
2923
2924
2925void MethodCompiler::EmitInsn_InvokeInterface(uint32_t dex_pc,
2926 Instruction const* insn,
2927 bool is_range) {
Logan Chien7caf37e2012-02-03 22:56:04 +08002928
2929 Instruction::DecodedInstruction dec_insn(insn);
2930
2931 uint32_t callee_method_idx = dec_insn.vB_;
2932
2933 // Resolve callee method
2934 Method* callee_method = ResolveMethod(callee_method_idx);
2935
2936 // Test: Is "this" pointer equal to null?
2937 llvm::Value* this_addr = EmitLoadCalleeThis(dec_insn, is_range);
2938 EmitGuard_NullPointerException(dex_pc, this_addr);
2939
2940 // Resolve the callee method object address at runtime
2941 llvm::Value* runtime_func = irb_.GetRuntime(FindInterfaceMethod);
2942
2943 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2944
2945 llvm::Value* callee_method_idx_value = irb_.getInt32(callee_method_idx);
2946
Logan Chien8dfcbea2012-02-17 18:50:32 +08002947 EmitUpdateLineNumFromDexPC(dex_pc);
2948
Logan Chien7caf37e2012-02-03 22:56:04 +08002949 llvm::Value* callee_method_object_addr =
2950 irb_.CreateCall2(runtime_func, callee_method_idx_value, method_object_addr);
2951
2952 EmitGuard_ExceptionLandingPad(dex_pc);
2953
2954 llvm::Value* code_addr =
2955 EmitLoadCodeAddr(callee_method_object_addr, callee_method_idx, false);
2956
2957 // Load the actual parameter
2958 std::vector<llvm::Value*> args;
2959 args.push_back(callee_method_object_addr);
2960 args.push_back(this_addr);
2961 EmitLoadActualParameters(args, callee_method_idx, dec_insn, is_range, false);
2962
Logan Chien8dfcbea2012-02-17 18:50:32 +08002963 // Invoke callee
2964 EmitUpdateLineNumFromDexPC(dex_pc);
Logan Chien7caf37e2012-02-03 22:56:04 +08002965 llvm::Value* retval = irb_.CreateCall(code_addr, args);
2966 EmitGuard_ExceptionLandingPad(dex_pc);
2967
2968 MethodHelper method_helper(callee_method);
2969 char ret_shorty = method_helper.GetShorty()[0];
2970 if (ret_shorty != 'V') {
2971 EmitStoreDalvikRetValReg(ret_shorty, kAccurate, retval);
2972 }
2973
Logan Chien70f94b42011-12-27 17:49:11 +08002974 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2975}
2976
2977
2978void MethodCompiler::EmitInsn_Neg(uint32_t dex_pc,
2979 Instruction const* insn,
2980 JType op_jty) {
Logan Chien1b5685f2011-12-27 18:01:14 +08002981
2982 Instruction::DecodedInstruction dec_insn(insn);
2983
2984 DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
2985
2986 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
2987 llvm::Value* result_value = irb_.CreateNeg(src_value);
2988 EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
2989
Logan Chien70f94b42011-12-27 17:49:11 +08002990 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2991}
2992
2993
2994void MethodCompiler::EmitInsn_Not(uint32_t dex_pc,
2995 Instruction const* insn,
2996 JType op_jty) {
Logan Chiene53750d2011-12-27 18:02:27 +08002997
2998 Instruction::DecodedInstruction dec_insn(insn);
2999
3000 DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
3001
3002 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
3003 llvm::Value* result_value =
3004 irb_.CreateXor(src_value, static_cast<uint64_t>(-1));
3005
3006 EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
3007
Logan Chien70f94b42011-12-27 17:49:11 +08003008 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3009}
3010
3011
3012void MethodCompiler::EmitInsn_SExt(uint32_t dex_pc,
3013 Instruction const* insn) {
Logan Chien61752ad2011-12-27 18:03:51 +08003014
3015 Instruction::DecodedInstruction dec_insn(insn);
3016
3017 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
3018 llvm::Value* result_value = irb_.CreateSExt(src_value, irb_.getJLongTy());
3019 EmitStoreDalvikReg(dec_insn.vA_, kLong, kAccurate, result_value);
3020
Logan Chien70f94b42011-12-27 17:49:11 +08003021 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3022}
3023
3024
3025void MethodCompiler::EmitInsn_Trunc(uint32_t dex_pc,
3026 Instruction const* insn) {
Logan Chien17a57662011-12-27 18:05:14 +08003027
3028 Instruction::DecodedInstruction dec_insn(insn);
3029
3030 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kLong, kAccurate);
3031 llvm::Value* result_value = irb_.CreateTrunc(src_value, irb_.getJIntTy());
3032 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
3033
Logan Chien70f94b42011-12-27 17:49:11 +08003034 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3035}
3036
3037
3038void MethodCompiler::EmitInsn_TruncAndSExt(uint32_t dex_pc,
3039 Instruction const* insn,
3040 unsigned N) {
Logan Chienb6744c52011-12-27 18:06:26 +08003041
3042 Instruction::DecodedInstruction dec_insn(insn);
3043
3044 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
3045
3046 llvm::Value* trunc_value =
3047 irb_.CreateTrunc(src_value, llvm::Type::getIntNTy(*context_, N));
3048
3049 llvm::Value* result_value = irb_.CreateSExt(trunc_value, irb_.getJIntTy());
3050
3051 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
3052
Logan Chien70f94b42011-12-27 17:49:11 +08003053 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3054}
3055
3056
3057void MethodCompiler::EmitInsn_TruncAndZExt(uint32_t dex_pc,
3058 Instruction const* insn,
3059 unsigned N) {
Logan Chienb6744c52011-12-27 18:06:26 +08003060
3061 Instruction::DecodedInstruction dec_insn(insn);
3062
3063 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
3064
3065 llvm::Value* trunc_value =
3066 irb_.CreateTrunc(src_value, llvm::Type::getIntNTy(*context_, N));
3067
3068 llvm::Value* result_value = irb_.CreateZExt(trunc_value, irb_.getJIntTy());
3069
3070 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
3071
Logan Chien70f94b42011-12-27 17:49:11 +08003072 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3073}
3074
3075
3076void MethodCompiler::EmitInsn_FNeg(uint32_t dex_pc,
3077 Instruction const* insn,
3078 JType op_jty) {
Logan Chien7a48b092011-12-27 18:07:45 +08003079
3080 Instruction::DecodedInstruction dec_insn(insn);
3081
3082 DCHECK(op_jty == kFloat || op_jty == kDouble) << op_jty;
3083
3084 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
3085 llvm::Value* result_value = irb_.CreateFNeg(src_value);
3086 EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
3087
Logan Chien70f94b42011-12-27 17:49:11 +08003088 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3089}
3090
3091
3092void MethodCompiler::EmitInsn_IntToFP(uint32_t dex_pc,
3093 Instruction const* insn,
3094 JType src_jty,
3095 JType dest_jty) {
Logan Chien62dd4532011-12-27 18:09:00 +08003096
3097 Instruction::DecodedInstruction dec_insn(insn);
3098
3099 DCHECK(src_jty == kInt || src_jty == kLong) << src_jty;
3100 DCHECK(dest_jty == kFloat || dest_jty == kDouble) << dest_jty;
3101
3102 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, src_jty, kAccurate);
3103 llvm::Type* dest_type = irb_.getJType(dest_jty, kAccurate);
3104 llvm::Value* dest_value = irb_.CreateSIToFP(src_value, dest_type);
3105 EmitStoreDalvikReg(dec_insn.vA_, dest_jty, kAccurate, dest_value);
3106
Logan Chien70f94b42011-12-27 17:49:11 +08003107 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3108}
3109
3110
3111void MethodCompiler::EmitInsn_FPToInt(uint32_t dex_pc,
3112 Instruction const* insn,
3113 JType src_jty,
3114 JType dest_jty) {
Logan Chien12dc1752011-12-27 18:10:15 +08003115
3116 Instruction::DecodedInstruction dec_insn(insn);
3117
3118 DCHECK(src_jty == kFloat || src_jty == kDouble) << src_jty;
3119 DCHECK(dest_jty == kInt || dest_jty == kLong) << dest_jty;
3120
3121 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, src_jty, kAccurate);
3122 llvm::Type* dest_type = irb_.getJType(dest_jty, kAccurate);
3123 llvm::Value* dest_value = irb_.CreateFPToSI(src_value, dest_type);
3124 EmitStoreDalvikReg(dec_insn.vA_, dest_jty, kAccurate, dest_value);
3125
Logan Chien70f94b42011-12-27 17:49:11 +08003126 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3127}
3128
3129
3130void MethodCompiler::EmitInsn_FExt(uint32_t dex_pc,
3131 Instruction const* insn) {
Logan Chienc56ded92011-12-27 18:10:57 +08003132
3133 Instruction::DecodedInstruction dec_insn(insn);
3134
3135 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kFloat, kAccurate);
3136 llvm::Value* result_value = irb_.CreateFPExt(src_value, irb_.getJDoubleTy());
3137 EmitStoreDalvikReg(dec_insn.vA_, kDouble, kAccurate, result_value);
3138
Logan Chien70f94b42011-12-27 17:49:11 +08003139 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3140}
3141
3142
3143void MethodCompiler::EmitInsn_FTrunc(uint32_t dex_pc,
3144 Instruction const* insn) {
Logan Chien927744f2011-12-27 18:11:52 +08003145
3146 Instruction::DecodedInstruction dec_insn(insn);
3147
3148 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kDouble, kAccurate);
3149 llvm::Value* result_value = irb_.CreateFPTrunc(src_value, irb_.getJFloatTy());
3150 EmitStoreDalvikReg(dec_insn.vA_, kFloat, kAccurate, result_value);
3151
Logan Chien70f94b42011-12-27 17:49:11 +08003152 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3153}
3154
3155
3156void MethodCompiler::EmitInsn_IntArithm(uint32_t dex_pc,
3157 Instruction const* insn,
3158 IntArithmKind arithm,
3159 JType op_jty,
3160 bool is_2addr) {
Logan Chienc3f7d962011-12-27 18:13:18 +08003161
3162 Instruction::DecodedInstruction dec_insn(insn);
3163
3164 DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
3165
3166 llvm::Value* src1_value;
3167 llvm::Value* src2_value;
3168
3169 if (is_2addr) {
3170 src1_value = EmitLoadDalvikReg(dec_insn.vA_, op_jty, kAccurate);
3171 src2_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
3172 } else {
3173 src1_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
3174 src2_value = EmitLoadDalvikReg(dec_insn.vC_, op_jty, kAccurate);
3175 }
3176
3177 llvm::Value* result_value =
3178 EmitIntArithmResultComputation(dex_pc, src1_value, src2_value,
3179 arithm, op_jty);
3180
3181 EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
3182
Logan Chien70f94b42011-12-27 17:49:11 +08003183 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3184}
3185
3186
3187void MethodCompiler::EmitInsn_IntArithmImmediate(uint32_t dex_pc,
3188 Instruction const* insn,
3189 IntArithmKind arithm) {
Logan Chienc3f7d962011-12-27 18:13:18 +08003190
3191 Instruction::DecodedInstruction dec_insn(insn);
3192
3193 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
3194
3195 llvm::Value* imm_value = irb_.getInt32(dec_insn.vC_);
3196
3197 llvm::Value* result_value =
3198 EmitIntArithmResultComputation(dex_pc, src_value, imm_value, arithm, kInt);
3199
3200 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
3201
Logan Chien70f94b42011-12-27 17:49:11 +08003202 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3203}
3204
3205
Logan Chienc3f7d962011-12-27 18:13:18 +08003206llvm::Value*
3207MethodCompiler::EmitIntArithmResultComputation(uint32_t dex_pc,
3208 llvm::Value* lhs,
3209 llvm::Value* rhs,
3210 IntArithmKind arithm,
3211 JType op_jty) {
3212 DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
3213
3214 switch (arithm) {
3215 case kIntArithm_Add:
3216 return irb_.CreateAdd(lhs, rhs);
3217
3218 case kIntArithm_Sub:
3219 return irb_.CreateSub(lhs, rhs);
3220
3221 case kIntArithm_Mul:
3222 return irb_.CreateMul(lhs, rhs);
3223
3224 case kIntArithm_Div:
3225 EmitGuard_DivZeroException(dex_pc, rhs, op_jty);
3226 return irb_.CreateSDiv(lhs, rhs);
3227
3228 case kIntArithm_Rem:
3229 EmitGuard_DivZeroException(dex_pc, rhs, op_jty);
3230 return irb_.CreateSRem(lhs, rhs);
3231
3232 case kIntArithm_And:
3233 return irb_.CreateAnd(lhs, rhs);
3234
3235 case kIntArithm_Or:
3236 return irb_.CreateOr(lhs, rhs);
3237
3238 case kIntArithm_Xor:
3239 return irb_.CreateXor(lhs, rhs);
3240
3241 case kIntArithm_Shl:
3242 if (op_jty == kLong) {
3243 return irb_.CreateShl(lhs, irb_.CreateAnd(rhs, 0x3f));
3244 } else {
3245 return irb_.CreateShl(lhs, irb_.CreateAnd(rhs, 0x1f));
3246 }
3247
3248 case kIntArithm_Shr:
3249 if (op_jty == kLong) {
3250 return irb_.CreateAShr(lhs, irb_.CreateAnd(rhs, 0x3f));
3251 } else {
3252 return irb_.CreateAShr(lhs, irb_.CreateAnd(rhs, 0x1f));
3253 }
3254
3255 case kIntArithm_UShr:
3256 if (op_jty == kLong) {
3257 return irb_.CreateLShr(lhs, irb_.CreateAnd(rhs, 0x3f));
3258 } else {
3259 return irb_.CreateLShr(lhs, irb_.CreateAnd(rhs, 0x1f));
3260 }
3261
3262 default:
3263 LOG(FATAL) << "Unknown integer arithmetic kind: " << arithm;
3264 return NULL;
3265 }
3266}
3267
3268
Logan Chien70f94b42011-12-27 17:49:11 +08003269void MethodCompiler::EmitInsn_RSubImmediate(uint32_t dex_pc,
3270 Instruction const* insn) {
Logan Chien65c62d42011-12-27 18:14:18 +08003271
3272 Instruction::DecodedInstruction dec_insn(insn);
3273
3274 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
3275 llvm::Value* imm_value = irb_.getInt32(dec_insn.vC_);
3276 llvm::Value* result_value = irb_.CreateSub(imm_value, src_value);
3277 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
3278
Logan Chien70f94b42011-12-27 17:49:11 +08003279 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3280}
3281
3282
3283void MethodCompiler::EmitInsn_FPArithm(uint32_t dex_pc,
3284 Instruction const* insn,
3285 FPArithmKind arithm,
3286 JType op_jty,
3287 bool is_2addr) {
Logan Chien76e1c792011-12-27 18:15:01 +08003288
3289 Instruction::DecodedInstruction dec_insn(insn);
3290
3291 DCHECK(op_jty == kFloat || op_jty == kDouble) << op_jty;
3292
3293 llvm::Value* src1_value;
3294 llvm::Value* src2_value;
3295
3296 if (is_2addr) {
3297 src1_value = EmitLoadDalvikReg(dec_insn.vA_, op_jty, kAccurate);
3298 src2_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
3299 } else {
3300 src1_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
3301 src2_value = EmitLoadDalvikReg(dec_insn.vC_, op_jty, kAccurate);
3302 }
3303
3304 llvm::Value* result_value =
3305 EmitFPArithmResultComputation(dex_pc, src1_value, src2_value, arithm);
3306
3307 EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
3308
Logan Chien70f94b42011-12-27 17:49:11 +08003309 irb_.CreateBr(GetNextBasicBlock(dex_pc));
3310}
3311
3312
Logan Chien76e1c792011-12-27 18:15:01 +08003313llvm::Value*
3314MethodCompiler::EmitFPArithmResultComputation(uint32_t dex_pc,
3315 llvm::Value *lhs,
3316 llvm::Value *rhs,
3317 FPArithmKind arithm) {
3318 switch (arithm) {
3319 case kFPArithm_Add:
3320 return irb_.CreateFAdd(lhs, rhs);
3321
3322 case kFPArithm_Sub:
3323 return irb_.CreateFSub(lhs, rhs);
3324
3325 case kFPArithm_Mul:
3326 return irb_.CreateFMul(lhs, rhs);
3327
3328 case kFPArithm_Div:
3329 return irb_.CreateFDiv(lhs, rhs);
3330
3331 case kFPArithm_Rem:
3332 return irb_.CreateFRem(lhs, rhs);
3333
3334 default:
3335 LOG(FATAL) << "Unknown floating-point arithmetic kind: " << arithm;
3336 return NULL;
3337 }
3338}
3339
3340
Logan Chienc3f7d962011-12-27 18:13:18 +08003341void MethodCompiler::EmitGuard_DivZeroException(uint32_t dex_pc,
3342 llvm::Value* denominator,
3343 JType op_jty) {
3344 DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
3345
3346 llvm::Constant* zero = irb_.getJZero(op_jty);
3347
3348 llvm::Value* equal_zero = irb_.CreateICmpEQ(denominator, zero);
3349
3350 llvm::BasicBlock* block_exception = CreateBasicBlockWithDexPC(dex_pc, "div0");
3351
3352 llvm::BasicBlock* block_continue = CreateBasicBlockWithDexPC(dex_pc, "cont");
3353
3354 irb_.CreateCondBr(equal_zero, block_exception, block_continue);
3355
3356 irb_.SetInsertPoint(block_exception);
Logan Chien8dfcbea2012-02-17 18:50:32 +08003357 EmitUpdateLineNumFromDexPC(dex_pc);
Logan Chienc3f7d962011-12-27 18:13:18 +08003358 irb_.CreateCall(irb_.GetRuntime(ThrowDivZeroException));
3359 EmitBranchExceptionLandingPad(dex_pc);
3360
3361 irb_.SetInsertPoint(block_continue);
3362}
3363
3364
Logan Chien46fbb412012-02-15 22:29:08 +08003365llvm::Value* MethodCompiler::EmitLoadClassObjectAddr(llvm::Value* this_addr) {
3366 llvm::Constant* class_field_offset_value =
3367 irb_.getPtrEquivInt(Object::ClassOffset().Int32Value());
3368
3369 llvm::Value* class_field_addr =
3370 irb_.CreatePtrDisp(this_addr, class_field_offset_value,
3371 irb_.getJObjectTy()->getPointerTo());
3372
3373 return irb_.CreateLoad(class_field_addr);
3374}
3375
3376
3377llvm::Value*
3378MethodCompiler::EmitLoadVTableAddr(llvm::Value* class_object_addr) {
3379 llvm::Constant* vtable_offset_value =
3380 irb_.getPtrEquivInt(Class::VTableOffset().Int32Value());
3381
3382 llvm::Value* vtable_field_addr =
3383 irb_.CreatePtrDisp(class_object_addr, vtable_offset_value,
3384 irb_.getJObjectTy()->getPointerTo());
3385
3386 return irb_.CreateLoad(vtable_field_addr);
3387}
3388
3389
3390llvm::Value* MethodCompiler::
3391EmitLoadMethodObjectAddrFromVTable(llvm::Value* vtable_addr,
3392 uint16_t vtable_index) {
3393 llvm::Value* vtable_index_value =
3394 irb_.getPtrEquivInt(static_cast<uint64_t>(vtable_index));
3395
3396 llvm::Value* method_field_addr =
3397 EmitArrayGEP(vtable_addr, vtable_index_value, irb_.getJObjectTy());
3398
3399 return irb_.CreateLoad(method_field_addr);
3400}
3401
3402
3403llvm::Value* MethodCompiler::EmitLoadCodeAddr(llvm::Value* method_object_addr,
3404 uint32_t method_idx,
3405 bool is_static) {
3406
3407 llvm::Value* code_field_offset_value =
3408 irb_.getPtrEquivInt(Method::GetCodeOffset().Int32Value());
3409
3410 llvm::FunctionType* method_type = GetFunctionType(method_idx, is_static);
3411
3412 llvm::Value* code_field_addr =
3413 irb_.CreatePtrDisp(method_object_addr, code_field_offset_value,
3414 method_type->getPointerTo()->getPointerTo());
3415
3416 return irb_.CreateLoad(code_field_addr);
3417}
3418
3419
Logan Chien61bb6142012-02-03 15:34:53 +08003420void MethodCompiler::EmitGuard_NullPointerException(uint32_t dex_pc,
3421 llvm::Value* object) {
3422 llvm::Value* equal_null = irb_.CreateICmpEQ(object, irb_.getJNull());
3423
3424 llvm::BasicBlock* block_exception =
3425 CreateBasicBlockWithDexPC(dex_pc, "nullp");
3426
3427 llvm::BasicBlock* block_continue =
3428 CreateBasicBlockWithDexPC(dex_pc, "cont");
3429
3430 irb_.CreateCondBr(equal_null, block_exception, block_continue);
3431
3432 irb_.SetInsertPoint(block_exception);
Logan Chien8dfcbea2012-02-17 18:50:32 +08003433 EmitUpdateLineNumFromDexPC(dex_pc);
Logan Chien61bb6142012-02-03 15:34:53 +08003434 irb_.CreateCall(irb_.GetRuntime(ThrowNullPointerException));
3435 EmitBranchExceptionLandingPad(dex_pc);
3436
3437 irb_.SetInsertPoint(block_continue);
3438}
3439
3440
Logan Chienbb4d12a2012-02-17 14:10:01 +08003441llvm::Value* MethodCompiler::EmitLoadDexCacheAddr(MemberOffset offset) {
3442 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
3443
3444 llvm::Value* dex_cache_offset_value =
3445 irb_.getPtrEquivInt(offset.Int32Value());
3446
3447 llvm::Value* dex_cache_field_addr =
3448 irb_.CreatePtrDisp(method_object_addr, dex_cache_offset_value,
3449 irb_.getJObjectTy()->getPointerTo());
3450
3451 return irb_.CreateLoad(dex_cache_field_addr);
3452}
3453
3454
Logan Chienbb4d12a2012-02-17 14:10:01 +08003455llvm::Value* MethodCompiler::
3456EmitLoadDexCacheStaticStorageFieldAddr(uint32_t type_idx) {
3457 llvm::Value* static_storage_dex_cache_addr =
3458 EmitLoadDexCacheAddr(Method::DexCacheInitializedStaticStorageOffset());
3459
3460 llvm::Value* type_idx_value = irb_.getPtrEquivInt(type_idx);
3461
3462 return EmitArrayGEP(static_storage_dex_cache_addr, type_idx_value,
3463 irb_.getJObjectTy());
3464}
3465
3466
3467llvm::Value* MethodCompiler::
3468EmitLoadDexCacheResolvedTypeFieldAddr(uint32_t type_idx) {
3469 llvm::Value* resolved_type_dex_cache_addr =
3470 EmitLoadDexCacheAddr(Method::DexCacheResolvedTypesOffset());
3471
3472 llvm::Value* type_idx_value = irb_.getPtrEquivInt(type_idx);
3473
3474 return EmitArrayGEP(resolved_type_dex_cache_addr, type_idx_value,
3475 irb_.getJObjectTy());
3476}
3477
3478
3479llvm::Value* MethodCompiler::
Logan Chien61c65dc2012-02-29 03:22:30 +08003480EmitLoadDexCacheResolvedMethodFieldAddr(uint32_t method_idx) {
3481 llvm::Value* resolved_method_dex_cache_addr =
3482 EmitLoadDexCacheAddr(Method::DexCacheResolvedMethodsOffset());
3483
3484 llvm::Value* method_idx_value = irb_.getPtrEquivInt(method_idx);
3485
3486 return EmitArrayGEP(resolved_method_dex_cache_addr, method_idx_value,
3487 irb_.getJObjectTy());
3488}
3489
3490
3491llvm::Value* MethodCompiler::
Logan Chienbb4d12a2012-02-17 14:10:01 +08003492EmitLoadDexCacheStringFieldAddr(uint32_t string_idx) {
3493 llvm::Value* string_dex_cache_addr =
3494 EmitLoadDexCacheAddr(Method::DexCacheStringsOffset());
3495
3496 llvm::Value* string_idx_value = irb_.getPtrEquivInt(string_idx);
3497
3498 return EmitArrayGEP(string_dex_cache_addr, string_idx_value,
3499 irb_.getJObjectTy());
3500}
3501
3502
Logan Chien83426162011-12-09 09:29:50 +08003503CompiledMethod *MethodCompiler::Compile() {
Logan Chien0b827102011-12-20 19:46:14 +08003504 // Code generation
3505 CreateFunction();
3506
3507 EmitPrologue();
3508 EmitInstructions();
Logan Chienc670a8d2011-12-20 21:25:56 +08003509 EmitPrologueLastBranch();
Logan Chien0b827102011-12-20 19:46:14 +08003510
Logan Chiend6c239a2011-12-23 15:11:45 +08003511 // Verify the generated bitcode
3512 llvm::verifyFunction(*func_, llvm::PrintMessageAction);
3513
Logan Chien0b827102011-12-20 19:46:14 +08003514 // Delete the inferred register category map (won't be used anymore)
3515 method_->ResetInferredRegCategoryMap();
3516
3517 return new CompiledMethod(insn_set_, func_);
3518}
3519
3520
3521llvm::Value* MethodCompiler::EmitLoadMethodObjectAddr() {
3522 return func_->arg_begin();
Shih-wei Liaod1fec812012-02-13 09:51:10 -08003523}
Logan Chien83426162011-12-09 09:29:50 +08003524
3525
Logan Chien5bcc04e2012-01-30 14:15:12 +08003526void MethodCompiler::EmitBranchExceptionLandingPad(uint32_t dex_pc) {
3527 if (llvm::BasicBlock* lpad = GetLandingPadBasicBlock(dex_pc)) {
3528 irb_.CreateBr(lpad);
3529 } else {
3530 irb_.CreateBr(GetUnwindBasicBlock());
3531 }
3532}
3533
3534
3535void MethodCompiler::EmitGuard_ExceptionLandingPad(uint32_t dex_pc) {
3536 llvm::Value* exception_pending =
3537 irb_.CreateCall(irb_.GetRuntime(IsExceptionPending));
3538
3539 llvm::BasicBlock* block_cont = CreateBasicBlockWithDexPC(dex_pc, "cont");
3540
3541 if (llvm::BasicBlock* lpad = GetLandingPadBasicBlock(dex_pc)) {
3542 irb_.CreateCondBr(exception_pending, lpad, block_cont);
3543 } else {
3544 irb_.CreateCondBr(exception_pending, GetUnwindBasicBlock(), block_cont);
3545 }
3546
3547 irb_.SetInsertPoint(block_cont);
3548}
3549
3550
Logan Chien924072f2012-01-30 15:07:24 +08003551void MethodCompiler::EmitGuard_GarbageCollectionSuspend(uint32_t dex_pc) {
3552 llvm::Value* runtime_func = irb_.GetRuntime(TestSuspend);
Logan Chien8dfcbea2012-02-17 18:50:32 +08003553 EmitUpdateLineNumFromDexPC(dex_pc);
Logan Chien924072f2012-01-30 15:07:24 +08003554 irb_.CreateCall(runtime_func);
3555
3556 EmitGuard_ExceptionLandingPad(dex_pc);
3557}
3558
3559
Logan Chiend6c239a2011-12-23 15:11:45 +08003560llvm::BasicBlock* MethodCompiler::
3561CreateBasicBlockWithDexPC(uint32_t dex_pc, char const* postfix) {
3562 std::string name;
3563
3564 if (postfix) {
3565 StringAppendF(&name, "B%u.%s", dex_pc, postfix);
3566 } else {
3567 StringAppendF(&name, "B%u", dex_pc);
3568 }
3569
3570 return llvm::BasicBlock::Create(*context_, name, func_);
3571}
3572
3573
3574llvm::BasicBlock* MethodCompiler::GetBasicBlock(uint32_t dex_pc) {
3575 DCHECK(dex_pc < code_item_->insns_size_in_code_units_);
3576
3577 llvm::BasicBlock* basic_block = basic_blocks_[dex_pc];
3578
3579 if (!basic_block) {
3580 basic_block = CreateBasicBlockWithDexPC(dex_pc);
3581 basic_blocks_[dex_pc] = basic_block;
3582 }
3583
3584 return basic_block;
3585}
3586
3587
3588llvm::BasicBlock*
3589MethodCompiler::GetNextBasicBlock(uint32_t dex_pc) {
3590 Instruction const* insn = Instruction::At(code_item_->insns_ + dex_pc);
3591 return GetBasicBlock(dex_pc + insn->SizeInCodeUnits());
3592}
3593
3594
Logan Chien5bcc04e2012-01-30 14:15:12 +08003595int32_t MethodCompiler::GetTryItemOffset(uint32_t dex_pc) {
3596 // TODO: Since we are emitting the dex instructions in ascending order
3597 // w.r.t. address, we can cache the lastest try item offset so that we
3598 // don't have to do binary search for every query.
3599
3600 int32_t min = 0;
3601 int32_t max = code_item_->tries_size_ - 1;
3602
3603 while (min <= max) {
3604 int32_t mid = min + (max - min) / 2;
3605
3606 DexFile::TryItem const* ti = DexFile::GetTryItems(*code_item_, mid);
3607 uint32_t start = ti->start_addr_;
3608 uint32_t end = start + ti->insn_count_;
3609
3610 if (dex_pc < start) {
3611 max = mid - 1;
3612 } else if (dex_pc >= end) {
3613 min = mid + 1;
3614 } else {
3615 return mid; // found
3616 }
3617 }
3618
3619 return -1; // not found
3620}
3621
3622
3623llvm::BasicBlock* MethodCompiler::GetLandingPadBasicBlock(uint32_t dex_pc) {
3624 // Find the try item for this address in this method
3625 int32_t ti_offset = GetTryItemOffset(dex_pc);
3626
3627 if (ti_offset == -1) {
3628 return NULL; // No landing pad is available for this address.
3629 }
3630
3631 // Check for the existing landing pad basic block
3632 DCHECK_GT(basic_block_landing_pads_.size(), static_cast<size_t>(ti_offset));
3633 llvm::BasicBlock* block_lpad = basic_block_landing_pads_[ti_offset];
3634
3635 if (block_lpad) {
3636 // We have generated landing pad for this try item already. Return the
3637 // same basic block.
3638 return block_lpad;
3639 }
3640
3641 // Get try item from code item
3642 DexFile::TryItem const* ti = DexFile::GetTryItems(*code_item_, ti_offset);
3643
3644 // Create landing pad basic block
3645 block_lpad = llvm::BasicBlock::Create(*context_,
3646 StringPrintf("lpad%d", ti_offset),
3647 func_);
3648
3649 // Change IRBuilder insert point
3650 llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
3651 irb_.SetInsertPoint(block_lpad);
3652
3653 // Find catch block with matching type
3654 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
3655
3656 // TODO: Maybe passing try item offset will be a better idea? For now,
3657 // we are passing dex_pc, so that we can use existing runtime support
3658 // function directly. However, in the runtime supporting function we
3659 // have to search for try item with binary search which can be
3660 // eliminated.
3661 llvm::Value* dex_pc_value = irb_.getInt32(ti->start_addr_);
3662
3663 llvm::Value* catch_handler_index_value =
3664 irb_.CreateCall2(irb_.GetRuntime(FindCatchBlock),
3665 method_object_addr, dex_pc_value);
3666
3667 // Switch instruction (Go to unwind basic block by default)
3668 llvm::SwitchInst* sw =
3669 irb_.CreateSwitch(catch_handler_index_value, GetUnwindBasicBlock());
3670
3671 // Cases with matched catch block
3672 CatchHandlerIterator iter(*code_item_, ti->start_addr_);
3673
3674 for (uint32_t c = 0; iter.HasNext(); iter.Next(), ++c) {
3675 sw->addCase(irb_.getInt32(c), GetBasicBlock(iter.GetHandlerAddress()));
3676 }
3677
3678 // Restore the orignal insert point for IRBuilder
3679 irb_.restoreIP(irb_ip_original);
3680
3681 // Cache this landing pad
3682 DCHECK_GT(basic_block_landing_pads_.size(), static_cast<size_t>(ti_offset));
3683 basic_block_landing_pads_[ti_offset] = block_lpad;
3684
3685 return block_lpad;
3686}
3687
3688
3689llvm::BasicBlock* MethodCompiler::GetUnwindBasicBlock() {
3690 // Check the existing unwinding baisc block block
3691 if (basic_block_unwind_ != NULL) {
3692 return basic_block_unwind_;
3693 }
3694
3695 // Create new basic block for unwinding
3696 basic_block_unwind_ =
3697 llvm::BasicBlock::Create(*context_, "exception_unwind", func_);
3698
3699 // Change IRBuilder insert point
3700 llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
3701 irb_.SetInsertPoint(basic_block_unwind_);
3702
Logan Chien8dfcbea2012-02-17 18:50:32 +08003703 // Pop the shadow frame
3704 EmitPopShadowFrame();
3705
Logan Chien5bcc04e2012-01-30 14:15:12 +08003706 // Emit the code to return default value (zero) for the given return type.
3707 char ret_shorty = method_helper_.GetShorty()[0];
3708 if (ret_shorty == 'V') {
3709 irb_.CreateRetVoid();
3710 } else {
3711 irb_.CreateRet(irb_.getJZero(ret_shorty));
3712 }
3713
3714 // Restore the orignal insert point for IRBuilder
3715 irb_.restoreIP(irb_ip_original);
3716
3717 return basic_block_unwind_;
3718}
3719
3720
Logan Chienc670a8d2011-12-20 21:25:56 +08003721llvm::Value* MethodCompiler::AllocDalvikLocalVarReg(RegCategory cat,
3722 uint32_t reg_idx) {
3723
3724 // Save current IR builder insert point
3725 llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
3726
3727 // Alloca
3728 llvm::Value* reg_addr = NULL;
3729
3730 switch (cat) {
3731 case kRegCat1nr:
3732 irb_.SetInsertPoint(basic_block_reg_alloca_);
3733 reg_addr = irb_.CreateAlloca(irb_.getJIntTy(), 0,
3734 StringPrintf("r%u", reg_idx));
3735
3736 irb_.SetInsertPoint(basic_block_reg_zero_init_);
3737 irb_.CreateStore(irb_.getJInt(0), reg_addr);
3738 break;
3739
3740 case kRegCat2:
3741 irb_.SetInsertPoint(basic_block_reg_alloca_);
3742 reg_addr = irb_.CreateAlloca(irb_.getJLongTy(), 0,
3743 StringPrintf("w%u", reg_idx));
3744
3745 irb_.SetInsertPoint(basic_block_reg_zero_init_);
3746 irb_.CreateStore(irb_.getJLong(0), reg_addr);
3747 break;
3748
3749 case kRegObject:
Logan Chien8dfcbea2012-02-17 18:50:32 +08003750 {
3751 irb_.SetInsertPoint(basic_block_shadow_frame_alloca_);
Logan Chienc670a8d2011-12-20 21:25:56 +08003752
Logan Chien8dfcbea2012-02-17 18:50:32 +08003753 llvm::Value* gep_index[] = {
3754 irb_.getInt32(0), // No pointer displacement
3755 irb_.getInt32(1), // SIRT
3756 irb_.getInt32(reg_idx) // Pointer field
3757 };
3758
3759 reg_addr = irb_.CreateGEP(shadow_frame_, gep_index,
3760 StringPrintf("p%u", reg_idx));
3761
3762 irb_.SetInsertPoint(basic_block_reg_zero_init_);
3763 irb_.CreateStore(irb_.getJNull(), reg_addr);
3764 }
Logan Chienc670a8d2011-12-20 21:25:56 +08003765 break;
3766
3767 default:
3768 LOG(FATAL) << "Unknown register category for allocation: " << cat;
3769 }
3770
3771 // Restore IRBuilder insert point
3772 irb_.restoreIP(irb_ip_original);
3773
3774 DCHECK_NE(reg_addr, static_cast<llvm::Value*>(NULL));
3775 return reg_addr;
3776}
3777
3778
3779llvm::Value* MethodCompiler::AllocDalvikRetValReg(RegCategory cat) {
3780 // Save current IR builder insert point
3781 llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
3782
3783 // Alloca
3784 llvm::Value* reg_addr = NULL;
3785
3786 switch (cat) {
3787 case kRegCat1nr:
3788 irb_.SetInsertPoint(basic_block_reg_alloca_);
3789 reg_addr = irb_.CreateAlloca(irb_.getJIntTy(), 0, "r_res");
3790 break;
3791
3792 case kRegCat2:
3793 irb_.SetInsertPoint(basic_block_reg_alloca_);
3794 reg_addr = irb_.CreateAlloca(irb_.getJLongTy(), 0, "w_res");
3795 break;
3796
3797 case kRegObject:
3798 irb_.SetInsertPoint(basic_block_reg_alloca_);
3799 reg_addr = irb_.CreateAlloca(irb_.getJObjectTy(), 0, "p_res");
3800 break;
3801
3802 default:
3803 LOG(FATAL) << "Unknown register category for allocation: " << cat;
3804 }
3805
3806 // Restore IRBuilder insert point
3807 irb_.restoreIP(irb_ip_original);
3808
3809 DCHECK_NE(reg_addr, static_cast<llvm::Value*>(NULL));
3810 return reg_addr;
3811}
3812
3813
Logan Chien8dfcbea2012-02-17 18:50:32 +08003814void MethodCompiler::EmitPopShadowFrame() {
3815 irb_.CreateCall(irb_.GetRuntime(PopShadowFrame));
3816}
3817
3818
3819void MethodCompiler::EmitUpdateLineNum(int32_t line_num) {
3820 llvm::Constant* zero = irb_.getInt32(0);
3821
3822 llvm::Value* gep_index[] = {
3823 zero, // No displacement for shadow frame pointer
3824 zero, // Get the %ArtFrame data structure
3825 irb_.getInt32(2),
3826 };
3827
3828 llvm::Value* line_num_field_addr = irb_.CreateGEP(shadow_frame_, gep_index);
3829 llvm::ConstantInt* line_num_value = irb_.getInt32(line_num);
3830 irb_.CreateStore(line_num_value, line_num_field_addr);
3831}
3832
3833
3834void MethodCompiler::EmitUpdateLineNumFromDexPC(uint32_t dex_pc) {
3835 EmitUpdateLineNum(dex_file_->GetLineNumFromPC(method_, dex_pc));
3836}
3837
3838
Logan Chien83426162011-12-09 09:29:50 +08003839} // namespace compiler_llvm
3840} // namespace art