blob: eaaac7294d2cd2061d72829a57c7d8f284a92b60 [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"
24#include "object.h"
25#include "object_utils.h"
Logan Chien42e0e152012-01-13 15:42:36 +080026#include "runtime_support_func.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080027#include "stl_util.h"
Logan Chien0b827102011-12-20 19:46:14 +080028#include "stringprintf.h"
29#include "utils_llvm.h"
Shih-wei Liaod1fec812012-02-13 09:51:10 -080030
31#include <iomanip>
32
33#include <llvm/Analysis/Verifier.h>
Logan Chienc670a8d2011-12-20 21:25:56 +080034#include <llvm/BasicBlock.h>
Shih-wei Liaod1fec812012-02-13 09:51:10 -080035#include <llvm/Function.h>
Logan Chiena85fb2f2012-01-16 12:52:56 +080036#include <llvm/GlobalVariable.h>
37#include <llvm/Intrinsics.h>
Shih-wei Liaod1fec812012-02-13 09:51:10 -080038
Logan Chien83426162011-12-09 09:29:50 +080039namespace art {
40namespace compiler_llvm {
Shih-wei Liaod1fec812012-02-13 09:51:10 -080041
Logan Chien42e0e152012-01-13 15:42:36 +080042using namespace runtime_support;
43
Shih-wei Liaod1fec812012-02-13 09:51:10 -080044
Logan Chien83426162011-12-09 09:29:50 +080045MethodCompiler::MethodCompiler(InstructionSet insn_set,
46 Compiler* compiler,
47 ClassLinker* class_linker,
48 ClassLoader const* class_loader,
49 DexFile const* dex_file,
50 DexCache* dex_cache,
51 DexFile::CodeItem const* code_item,
Shih-wei Liaod1fec812012-02-13 09:51:10 -080052 uint32_t method_idx,
53 uint32_t access_flags)
54: insn_set_(insn_set),
55 compiler_(compiler), compiler_llvm_(compiler->GetCompilerLLVM()),
56 class_linker_(class_linker), class_loader_(class_loader),
57 dex_file_(dex_file), dex_cache_(dex_cache), code_item_(code_item),
58 method_(dex_cache->GetResolvedMethod(method_idx)),
59 method_helper_(method_), method_idx_(method_idx),
60 access_flags_(access_flags), module_(compiler_llvm_->GetModule()),
61 context_(compiler_llvm_->GetLLVMContext()),
Logan Chienc670a8d2011-12-20 21:25:56 +080062 irb_(*compiler_llvm_->GetIRBuilder()), func_(NULL), retval_reg_(NULL),
Logan Chiend6ececa2011-12-27 16:20:15 +080063 basic_block_reg_alloca_(NULL),
64 basic_block_reg_zero_init_(NULL), basic_block_reg_arg_init_(NULL),
Logan Chien5bcc04e2012-01-30 14:15:12 +080065 basic_blocks_(code_item->insns_size_in_code_units_),
66 basic_block_landing_pads_(code_item->tries_size_, NULL),
67 basic_block_unwind_(NULL), basic_block_unreachable_(NULL) {
Shih-wei Liaod1fec812012-02-13 09:51:10 -080068}
69
70
71MethodCompiler::~MethodCompiler() {
Logan Chienc670a8d2011-12-20 21:25:56 +080072 STLDeleteElements(&regs_);
Shih-wei Liaod1fec812012-02-13 09:51:10 -080073}
74
75
Logan Chien0b827102011-12-20 19:46:14 +080076void MethodCompiler::CreateFunction() {
77 // LLVM function name
78 std::string func_name(LLVMLongName(method_));
79
80 // Get function type
81 llvm::FunctionType* func_type =
82 GetFunctionType(method_idx_, method_->IsStatic());
83
84 // Create function
85 func_ = llvm::Function::Create(func_type, llvm::Function::ExternalLinkage,
86 func_name, module_);
87
88 // Set argument name
89 llvm::Function::arg_iterator arg_iter(func_->arg_begin());
90 llvm::Function::arg_iterator arg_end(func_->arg_end());
91
92 DCHECK_NE(arg_iter, arg_end);
93 arg_iter->setName("method");
94 ++arg_iter;
95
96 if (!method_->IsStatic()) {
97 DCHECK_NE(arg_iter, arg_end);
98 arg_iter->setName("this");
99 ++arg_iter;
100 }
101
102 for (unsigned i = 0; arg_iter != arg_end; ++i, ++arg_iter) {
103 arg_iter->setName(StringPrintf("a%u", i));
104 }
105}
106
107
108llvm::FunctionType* MethodCompiler::GetFunctionType(uint32_t method_idx,
109 bool is_static) {
110 // Get method signature
111 DexFile::MethodId const& method_id = dex_file_->GetMethodId(method_idx);
112
113 int32_t shorty_size;
114 char const* shorty = dex_file_->GetMethodShorty(method_id, &shorty_size);
115 CHECK_GE(shorty_size, 1);
116
117 // Get return type
118 llvm::Type* ret_type = irb_.getJType(shorty[0], kAccurate);
119
120 // Get argument type
121 std::vector<llvm::Type*> args_type;
122
123 args_type.push_back(irb_.getJObjectTy()); // method object pointer
124
125 if (!is_static) {
126 args_type.push_back(irb_.getJType('L', kAccurate)); // "this" object pointer
127 }
128
129 for (int32_t i = 1; i < shorty_size; ++i) {
130 args_type.push_back(irb_.getJType(shorty[i], kAccurate));
131 }
132
133 return llvm::FunctionType::get(ret_type, args_type, false);
134}
135
136
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800137void MethodCompiler::EmitPrologue() {
Logan Chienc670a8d2011-12-20 21:25:56 +0800138 // Create basic blocks for prologue
139 basic_block_reg_alloca_ =
140 llvm::BasicBlock::Create(*context_, "prologue.alloca", func_);
141
142 basic_block_reg_zero_init_ =
143 llvm::BasicBlock::Create(*context_, "prologue.zeroinit", func_);
144
Logan Chiend6ececa2011-12-27 16:20:15 +0800145 basic_block_reg_arg_init_ =
146 llvm::BasicBlock::Create(*context_, "prologue.arginit", func_);
147
Logan Chienc670a8d2011-12-20 21:25:56 +0800148 // Create register array
149 for (uint16_t r = 0; r < code_item_->registers_size_; ++r) {
150 regs_.push_back(DalvikReg::CreateLocalVarReg(*this, r));
151 }
152
153 retval_reg_.reset(DalvikReg::CreateRetValReg(*this));
Logan Chiend6ececa2011-12-27 16:20:15 +0800154
155 // Store argument to dalvik register
156 irb_.SetInsertPoint(basic_block_reg_arg_init_);
157 EmitPrologueAssignArgRegister();
158
159 // Branch to start address
160 irb_.CreateBr(GetBasicBlock(0));
Logan Chienc670a8d2011-12-20 21:25:56 +0800161}
162
163
164void MethodCompiler::EmitPrologueLastBranch() {
165 irb_.SetInsertPoint(basic_block_reg_alloca_);
166 irb_.CreateBr(basic_block_reg_zero_init_);
167
168 irb_.SetInsertPoint(basic_block_reg_zero_init_);
Logan Chiend6ececa2011-12-27 16:20:15 +0800169 irb_.CreateBr(basic_block_reg_arg_init_);
170}
171
172
173void MethodCompiler::EmitPrologueAssignArgRegister() {
174 uint16_t arg_reg = code_item_->registers_size_ - code_item_->ins_size_;
175
176 llvm::Function::arg_iterator arg_iter(func_->arg_begin());
177 llvm::Function::arg_iterator arg_end(func_->arg_end());
178
179 char const* shorty = method_helper_.GetShorty();
180 int32_t shorty_size = method_helper_.GetShortyLength();
181 CHECK_LE(1, shorty_size);
182
183 ++arg_iter; // skip method object
184
185 if (!method_->IsStatic()) {
186 EmitStoreDalvikReg(arg_reg, kObject, kAccurate, arg_iter);
187 ++arg_iter;
188 ++arg_reg;
189 }
190
191 for (int32_t i = 1; i < shorty_size; ++i, ++arg_iter) {
192 EmitStoreDalvikReg(arg_reg, shorty[i], kAccurate, arg_iter);
193
194 ++arg_reg;
195 if (shorty[i] == 'J' || shorty[i] == 'D') {
196 // Wide types, such as long and double, are using a pair of registers
197 // to store the value, so we have to increase arg_reg again.
198 ++arg_reg;
199 }
200 }
201
202 DCHECK_EQ(arg_end, arg_iter);
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800203}
204
205
Logan Chien83426162011-12-09 09:29:50 +0800206void MethodCompiler::EmitInstructions() {
Logan Chiend6c239a2011-12-23 15:11:45 +0800207 uint32_t dex_pc = 0;
208 while (dex_pc < code_item_->insns_size_in_code_units_) {
209 Instruction const* insn = Instruction::At(code_item_->insns_ + dex_pc);
210 EmitInstruction(dex_pc, insn);
211 dex_pc += insn->SizeInCodeUnits();
212 }
Shih-wei Liaod1fec812012-02-13 09:51:10 -0800213}
214
215
Logan Chien83426162011-12-09 09:29:50 +0800216void MethodCompiler::EmitInstruction(uint32_t dex_pc,
217 Instruction const* insn) {
Logan Chiend6c239a2011-12-23 15:11:45 +0800218
219 // Set the IRBuilder insertion point
220 irb_.SetInsertPoint(GetBasicBlock(dex_pc));
221
Logan Chien70f94b42011-12-27 17:49:11 +0800222#define ARGS dex_pc, insn
223
224 // Dispatch the instruction
225 switch (insn->Opcode()) {
226 case Instruction::NOP:
227 EmitInsn_Nop(ARGS);
228 break;
229
230 case Instruction::MOVE:
231 case Instruction::MOVE_FROM16:
232 case Instruction::MOVE_16:
233 EmitInsn_Move(ARGS, kInt);
234 break;
235
236 case Instruction::MOVE_WIDE:
237 case Instruction::MOVE_WIDE_FROM16:
238 case Instruction::MOVE_WIDE_16:
239 EmitInsn_Move(ARGS, kLong);
240 break;
241
242 case Instruction::MOVE_OBJECT:
243 case Instruction::MOVE_OBJECT_FROM16:
244 case Instruction::MOVE_OBJECT_16:
245 EmitInsn_Move(ARGS, kObject);
246 break;
247
248 case Instruction::MOVE_RESULT:
249 EmitInsn_MoveResult(ARGS, kInt);
250 break;
251
252 case Instruction::MOVE_RESULT_WIDE:
253 EmitInsn_MoveResult(ARGS, kLong);
254 break;
255
256 case Instruction::MOVE_RESULT_OBJECT:
257 EmitInsn_MoveResult(ARGS, kObject);
258 break;
259
260 case Instruction::MOVE_EXCEPTION:
261 EmitInsn_MoveException(ARGS);
262 break;
263
264 case Instruction::RETURN_VOID:
265 EmitInsn_ReturnVoid(ARGS);
266 break;
267
268 case Instruction::RETURN:
269 case Instruction::RETURN_WIDE:
270 case Instruction::RETURN_OBJECT:
271 EmitInsn_Return(ARGS);
272 break;
273
274 case Instruction::CONST_4:
275 case Instruction::CONST_16:
276 case Instruction::CONST:
277 case Instruction::CONST_HIGH16:
278 EmitInsn_LoadConstant(ARGS, kInt);
279 break;
280
281 case Instruction::CONST_WIDE_16:
282 case Instruction::CONST_WIDE_32:
283 case Instruction::CONST_WIDE:
284 case Instruction::CONST_WIDE_HIGH16:
285 EmitInsn_LoadConstant(ARGS, kLong);
286 break;
287
288 case Instruction::CONST_STRING:
289 case Instruction::CONST_STRING_JUMBO:
290 EmitInsn_LoadConstantString(ARGS);
291 break;
292
293 case Instruction::CONST_CLASS:
294 EmitInsn_LoadConstantClass(ARGS);
295 break;
296
297 case Instruction::MONITOR_ENTER:
298 EmitInsn_MonitorEnter(ARGS);
299 break;
300
301 case Instruction::MONITOR_EXIT:
302 EmitInsn_MonitorExit(ARGS);
303 break;
304
305 case Instruction::CHECK_CAST:
306 EmitInsn_CheckCast(ARGS);
307 break;
308
309 case Instruction::INSTANCE_OF:
310 EmitInsn_InstanceOf(ARGS);
311 break;
312
313 case Instruction::ARRAY_LENGTH:
314 EmitInsn_ArrayLength(ARGS);
315 break;
316
317 case Instruction::NEW_INSTANCE:
318 EmitInsn_NewInstance(ARGS);
319 break;
320
321 case Instruction::NEW_ARRAY:
322 EmitInsn_NewArray(ARGS);
323 break;
324
325 case Instruction::FILLED_NEW_ARRAY:
326 EmitInsn_FilledNewArray(ARGS, false);
327 break;
328
329 case Instruction::FILLED_NEW_ARRAY_RANGE:
330 EmitInsn_FilledNewArray(ARGS, true);
331 break;
332
333 case Instruction::FILL_ARRAY_DATA:
334 EmitInsn_FillArrayData(ARGS);
335 break;
336
337 case Instruction::THROW:
338 EmitInsn_ThrowException(ARGS);
339 break;
340
341 case Instruction::GOTO:
342 case Instruction::GOTO_16:
343 case Instruction::GOTO_32:
344 EmitInsn_UnconditionalBranch(ARGS);
345 break;
346
347 case Instruction::PACKED_SWITCH:
348 EmitInsn_PackedSwitch(ARGS);
349 break;
350
351 case Instruction::SPARSE_SWITCH:
352 EmitInsn_SparseSwitch(ARGS);
353 break;
354
355 case Instruction::CMPL_FLOAT:
356 EmitInsn_FPCompare(ARGS, kFloat, false);
357 break;
358
359 case Instruction::CMPG_FLOAT:
360 EmitInsn_FPCompare(ARGS, kFloat, true);
361 break;
362
363 case Instruction::CMPL_DOUBLE:
364 EmitInsn_FPCompare(ARGS, kDouble, false);
365 break;
366
367 case Instruction::CMPG_DOUBLE:
368 EmitInsn_FPCompare(ARGS, kDouble, true);
369 break;
370
371 case Instruction::CMP_LONG:
372 EmitInsn_LongCompare(ARGS);
373 break;
374
375 case Instruction::IF_EQ:
376 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_EQ);
377 break;
378
379 case Instruction::IF_NE:
380 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_NE);
381 break;
382
383 case Instruction::IF_LT:
384 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_LT);
385 break;
386
387 case Instruction::IF_GE:
388 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_GE);
389 break;
390
391 case Instruction::IF_GT:
392 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_GT);
393 break;
394
395 case Instruction::IF_LE:
396 EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_LE);
397 break;
398
399 case Instruction::IF_EQZ:
400 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_EQ);
401 break;
402
403 case Instruction::IF_NEZ:
404 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_NE);
405 break;
406
407 case Instruction::IF_LTZ:
408 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_LT);
409 break;
410
411 case Instruction::IF_GEZ:
412 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_GE);
413 break;
414
415 case Instruction::IF_GTZ:
416 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_GT);
417 break;
418
419 case Instruction::IF_LEZ:
420 EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_LE);
421 break;
422
423 case Instruction::AGET:
424 EmitInsn_AGet(ARGS, kInt);
425 break;
426
427 case Instruction::AGET_WIDE:
428 EmitInsn_AGet(ARGS, kLong);
429 break;
430
431 case Instruction::AGET_OBJECT:
432 EmitInsn_AGet(ARGS, kObject);
433 break;
434
435 case Instruction::AGET_BOOLEAN:
436 EmitInsn_AGet(ARGS, kBoolean);
437 break;
438
439 case Instruction::AGET_BYTE:
440 EmitInsn_AGet(ARGS, kByte);
441 break;
442
443 case Instruction::AGET_CHAR:
444 EmitInsn_AGet(ARGS, kChar);
445 break;
446
447 case Instruction::AGET_SHORT:
448 EmitInsn_AGet(ARGS, kShort);
449 break;
450
451 case Instruction::APUT:
452 EmitInsn_APut(ARGS, kInt);
453 break;
454
455 case Instruction::APUT_WIDE:
456 EmitInsn_APut(ARGS, kLong);
457 break;
458
459 case Instruction::APUT_OBJECT:
460 EmitInsn_APut(ARGS, kObject);
461 break;
462
463 case Instruction::APUT_BOOLEAN:
464 EmitInsn_APut(ARGS, kBoolean);
465 break;
466
467 case Instruction::APUT_BYTE:
468 EmitInsn_APut(ARGS, kByte);
469 break;
470
471 case Instruction::APUT_CHAR:
472 EmitInsn_APut(ARGS, kChar);
473 break;
474
475 case Instruction::APUT_SHORT:
476 EmitInsn_APut(ARGS, kShort);
477 break;
478
479 case Instruction::IGET:
480 EmitInsn_IGet(ARGS, kInt);
481 break;
482
483 case Instruction::IGET_WIDE:
484 EmitInsn_IGet(ARGS, kLong);
485 break;
486
487 case Instruction::IGET_OBJECT:
488 EmitInsn_IGet(ARGS, kObject);
489 break;
490
491 case Instruction::IGET_BOOLEAN:
492 EmitInsn_IGet(ARGS, kBoolean);
493 break;
494
495 case Instruction::IGET_BYTE:
496 EmitInsn_IGet(ARGS, kByte);
497 break;
498
499 case Instruction::IGET_CHAR:
500 EmitInsn_IGet(ARGS, kChar);
501 break;
502
503 case Instruction::IGET_SHORT:
504 EmitInsn_IGet(ARGS, kShort);
505 break;
506
507 case Instruction::IPUT:
508 EmitInsn_IPut(ARGS, kInt);
509 break;
510
511 case Instruction::IPUT_WIDE:
512 EmitInsn_IPut(ARGS, kLong);
513 break;
514
515 case Instruction::IPUT_OBJECT:
516 EmitInsn_IPut(ARGS, kObject);
517 break;
518
519 case Instruction::IPUT_BOOLEAN:
520 EmitInsn_IPut(ARGS, kBoolean);
521 break;
522
523 case Instruction::IPUT_BYTE:
524 EmitInsn_IPut(ARGS, kByte);
525 break;
526
527 case Instruction::IPUT_CHAR:
528 EmitInsn_IPut(ARGS, kChar);
529 break;
530
531 case Instruction::IPUT_SHORT:
532 EmitInsn_IPut(ARGS, kShort);
533 break;
534
535 case Instruction::SGET:
536 EmitInsn_SGet(ARGS, kInt);
537 break;
538
539 case Instruction::SGET_WIDE:
540 EmitInsn_SGet(ARGS, kLong);
541 break;
542
543 case Instruction::SGET_OBJECT:
544 EmitInsn_SGet(ARGS, kObject);
545 break;
546
547 case Instruction::SGET_BOOLEAN:
548 EmitInsn_SGet(ARGS, kBoolean);
549 break;
550
551 case Instruction::SGET_BYTE:
552 EmitInsn_SGet(ARGS, kByte);
553 break;
554
555 case Instruction::SGET_CHAR:
556 EmitInsn_SGet(ARGS, kChar);
557 break;
558
559 case Instruction::SGET_SHORT:
560 EmitInsn_SGet(ARGS, kShort);
561 break;
562
563 case Instruction::SPUT:
564 EmitInsn_SPut(ARGS, kInt);
565 break;
566
567 case Instruction::SPUT_WIDE:
568 EmitInsn_SPut(ARGS, kLong);
569 break;
570
571 case Instruction::SPUT_OBJECT:
572 EmitInsn_SPut(ARGS, kObject);
573 break;
574
575 case Instruction::SPUT_BOOLEAN:
576 EmitInsn_SPut(ARGS, kBoolean);
577 break;
578
579 case Instruction::SPUT_BYTE:
580 EmitInsn_SPut(ARGS, kByte);
581 break;
582
583 case Instruction::SPUT_CHAR:
584 EmitInsn_SPut(ARGS, kChar);
585 break;
586
587 case Instruction::SPUT_SHORT:
588 EmitInsn_SPut(ARGS, kShort);
589 break;
590
591
592 case Instruction::INVOKE_VIRTUAL:
593 EmitInsn_InvokeVirtual(ARGS, false);
594 break;
595
596 case Instruction::INVOKE_SUPER:
597 EmitInsn_InvokeSuper(ARGS, false);
598 break;
599
600 case Instruction::INVOKE_DIRECT:
601 EmitInsn_InvokeDirect(ARGS, false);
602 break;
603
604 case Instruction::INVOKE_STATIC:
605 EmitInsn_InvokeStatic(ARGS, false);
606 break;
607
608 case Instruction::INVOKE_INTERFACE:
609 EmitInsn_InvokeInterface(ARGS, false);
610 break;
611
612 case Instruction::INVOKE_VIRTUAL_RANGE:
613 EmitInsn_InvokeVirtual(ARGS, true);
614 break;
615
616 case Instruction::INVOKE_SUPER_RANGE:
617 EmitInsn_InvokeSuper(ARGS, true);
618 break;
619
620 case Instruction::INVOKE_DIRECT_RANGE:
621 EmitInsn_InvokeDirect(ARGS, true);
622 break;
623
624 case Instruction::INVOKE_STATIC_RANGE:
625 EmitInsn_InvokeStatic(ARGS, true);
626 break;
627
628 case Instruction::INVOKE_INTERFACE_RANGE:
629 EmitInsn_InvokeInterface(ARGS, true);
630 break;
631
632 case Instruction::NEG_INT:
633 EmitInsn_Neg(ARGS, kInt);
634 break;
635
636 case Instruction::NOT_INT:
637 EmitInsn_Not(ARGS, kInt);
638 break;
639
640 case Instruction::NEG_LONG:
641 EmitInsn_Neg(ARGS, kLong);
642 break;
643
644 case Instruction::NOT_LONG:
645 EmitInsn_Not(ARGS, kLong);
646 break;
647
648 case Instruction::NEG_FLOAT:
649 EmitInsn_FNeg(ARGS, kFloat);
650 break;
651
652 case Instruction::NEG_DOUBLE:
653 EmitInsn_FNeg(ARGS, kDouble);
654 break;
655
656 case Instruction::INT_TO_LONG:
657 EmitInsn_SExt(ARGS);
658 break;
659
660 case Instruction::INT_TO_FLOAT:
661 EmitInsn_IntToFP(ARGS, kInt, kFloat);
662 break;
663
664 case Instruction::INT_TO_DOUBLE:
665 EmitInsn_IntToFP(ARGS, kInt, kDouble);
666 break;
667
668 case Instruction::LONG_TO_INT:
669 EmitInsn_Trunc(ARGS);
670 break;
671
672 case Instruction::LONG_TO_FLOAT:
673 EmitInsn_IntToFP(ARGS, kLong, kFloat);
674 break;
675
676 case Instruction::LONG_TO_DOUBLE:
677 EmitInsn_IntToFP(ARGS, kLong, kDouble);
678 break;
679
680 case Instruction::FLOAT_TO_INT:
681 EmitInsn_FPToInt(ARGS, kFloat, kInt);
682 break;
683
684 case Instruction::FLOAT_TO_LONG:
685 EmitInsn_FPToInt(ARGS, kFloat, kLong);
686 break;
687
688 case Instruction::FLOAT_TO_DOUBLE:
689 EmitInsn_FExt(ARGS);
690 break;
691
692 case Instruction::DOUBLE_TO_INT:
693 EmitInsn_FPToInt(ARGS, kDouble, kInt);
694 break;
695
696 case Instruction::DOUBLE_TO_LONG:
697 EmitInsn_FPToInt(ARGS, kDouble, kLong);
698 break;
699
700 case Instruction::DOUBLE_TO_FLOAT:
701 EmitInsn_FTrunc(ARGS);
702 break;
703
704 case Instruction::INT_TO_BYTE:
705 EmitInsn_TruncAndSExt(ARGS, 8);
706 break;
707
708 case Instruction::INT_TO_CHAR:
709 EmitInsn_TruncAndZExt(ARGS, 16);
710 break;
711
712 case Instruction::INT_TO_SHORT:
713 EmitInsn_TruncAndSExt(ARGS, 16);
714 break;
715
716 case Instruction::ADD_INT:
717 EmitInsn_IntArithm(ARGS, kIntArithm_Add, kInt, false);
718 break;
719
720 case Instruction::SUB_INT:
721 EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kInt, false);
722 break;
723
724 case Instruction::MUL_INT:
725 EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kInt, false);
726 break;
727
728 case Instruction::DIV_INT:
729 EmitInsn_IntArithm(ARGS, kIntArithm_Div, kInt, false);
730 break;
731
732 case Instruction::REM_INT:
733 EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kInt, false);
734 break;
735
736 case Instruction::AND_INT:
737 EmitInsn_IntArithm(ARGS, kIntArithm_And, kInt, false);
738 break;
739
740 case Instruction::OR_INT:
741 EmitInsn_IntArithm(ARGS, kIntArithm_Or, kInt, false);
742 break;
743
744 case Instruction::XOR_INT:
745 EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kInt, false);
746 break;
747
748 case Instruction::SHL_INT:
749 EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kInt, false);
750 break;
751
752 case Instruction::SHR_INT:
753 EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kInt, false);
754 break;
755
756 case Instruction::USHR_INT:
757 EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kInt, false);
758 break;
759
760 case Instruction::ADD_LONG:
761 EmitInsn_IntArithm(ARGS, kIntArithm_Add, kLong, false);
762 break;
763
764 case Instruction::SUB_LONG:
765 EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kLong, false);
766 break;
767
768 case Instruction::MUL_LONG:
769 EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kLong, false);
770 break;
771
772 case Instruction::DIV_LONG:
773 EmitInsn_IntArithm(ARGS, kIntArithm_Div, kLong, false);
774 break;
775
776 case Instruction::REM_LONG:
777 EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kLong, false);
778 break;
779
780 case Instruction::AND_LONG:
781 EmitInsn_IntArithm(ARGS, kIntArithm_And, kLong, false);
782 break;
783
784 case Instruction::OR_LONG:
785 EmitInsn_IntArithm(ARGS, kIntArithm_Or, kLong, false);
786 break;
787
788 case Instruction::XOR_LONG:
789 EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kLong, false);
790 break;
791
792 case Instruction::SHL_LONG:
793 EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kLong, false);
794 break;
795
796 case Instruction::SHR_LONG:
797 EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kLong, false);
798 break;
799
800 case Instruction::USHR_LONG:
801 EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kLong, false);
802 break;
803
804 case Instruction::ADD_FLOAT:
805 EmitInsn_FPArithm(ARGS, kFPArithm_Add, kFloat, false);
806 break;
807
808 case Instruction::SUB_FLOAT:
809 EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kFloat, false);
810 break;
811
812 case Instruction::MUL_FLOAT:
813 EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kFloat, false);
814 break;
815
816 case Instruction::DIV_FLOAT:
817 EmitInsn_FPArithm(ARGS, kFPArithm_Div, kFloat, false);
818 break;
819
820 case Instruction::REM_FLOAT:
821 EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kFloat, false);
822 break;
823
824 case Instruction::ADD_DOUBLE:
825 EmitInsn_FPArithm(ARGS, kFPArithm_Add, kDouble, false);
826 break;
827
828 case Instruction::SUB_DOUBLE:
829 EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kDouble, false);
830 break;
831
832 case Instruction::MUL_DOUBLE:
833 EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kDouble, false);
834 break;
835
836 case Instruction::DIV_DOUBLE:
837 EmitInsn_FPArithm(ARGS, kFPArithm_Div, kDouble, false);
838 break;
839
840 case Instruction::REM_DOUBLE:
841 EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kDouble, false);
842 break;
843
844 case Instruction::ADD_INT_2ADDR:
845 EmitInsn_IntArithm(ARGS, kIntArithm_Add, kInt, true);
846 break;
847
848 case Instruction::SUB_INT_2ADDR:
849 EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kInt, true);
850 break;
851
852 case Instruction::MUL_INT_2ADDR:
853 EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kInt, true);
854 break;
855
856 case Instruction::DIV_INT_2ADDR:
857 EmitInsn_IntArithm(ARGS, kIntArithm_Div, kInt, true);
858 break;
859
860 case Instruction::REM_INT_2ADDR:
861 EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kInt, true);
862 break;
863
864 case Instruction::AND_INT_2ADDR:
865 EmitInsn_IntArithm(ARGS, kIntArithm_And, kInt, true);
866 break;
867
868 case Instruction::OR_INT_2ADDR:
869 EmitInsn_IntArithm(ARGS, kIntArithm_Or, kInt, true);
870 break;
871
872 case Instruction::XOR_INT_2ADDR:
873 EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kInt, true);
874 break;
875
876 case Instruction::SHL_INT_2ADDR:
877 EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kInt, true);
878 break;
879
880 case Instruction::SHR_INT_2ADDR:
881 EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kInt, true);
882 break;
883
884 case Instruction::USHR_INT_2ADDR:
885 EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kInt, true);
886 break;
887
888 case Instruction::ADD_LONG_2ADDR:
889 EmitInsn_IntArithm(ARGS, kIntArithm_Add, kLong, true);
890 break;
891
892 case Instruction::SUB_LONG_2ADDR:
893 EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kLong, true);
894 break;
895
896 case Instruction::MUL_LONG_2ADDR:
897 EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kLong, true);
898 break;
899
900 case Instruction::DIV_LONG_2ADDR:
901 EmitInsn_IntArithm(ARGS, kIntArithm_Div, kLong, true);
902 break;
903
904 case Instruction::REM_LONG_2ADDR:
905 EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kLong, true);
906 break;
907
908 case Instruction::AND_LONG_2ADDR:
909 EmitInsn_IntArithm(ARGS, kIntArithm_And, kLong, true);
910 break;
911
912 case Instruction::OR_LONG_2ADDR:
913 EmitInsn_IntArithm(ARGS, kIntArithm_Or, kLong, true);
914 break;
915
916 case Instruction::XOR_LONG_2ADDR:
917 EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kLong, true);
918 break;
919
920 case Instruction::SHL_LONG_2ADDR:
921 EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kLong, true);
922 break;
923
924 case Instruction::SHR_LONG_2ADDR:
925 EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kLong, true);
926 break;
927
928 case Instruction::USHR_LONG_2ADDR:
929 EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kLong, true);
930 break;
931
932 case Instruction::ADD_FLOAT_2ADDR:
933 EmitInsn_FPArithm(ARGS, kFPArithm_Add, kFloat, true);
934 break;
935
936 case Instruction::SUB_FLOAT_2ADDR:
937 EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kFloat, true);
938 break;
939
940 case Instruction::MUL_FLOAT_2ADDR:
941 EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kFloat, true);
942 break;
943
944 case Instruction::DIV_FLOAT_2ADDR:
945 EmitInsn_FPArithm(ARGS, kFPArithm_Div, kFloat, true);
946 break;
947
948 case Instruction::REM_FLOAT_2ADDR:
949 EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kFloat, true);
950 break;
951
952 case Instruction::ADD_DOUBLE_2ADDR:
953 EmitInsn_FPArithm(ARGS, kFPArithm_Add, kDouble, true);
954 break;
955
956 case Instruction::SUB_DOUBLE_2ADDR:
957 EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kDouble, true);
958 break;
959
960 case Instruction::MUL_DOUBLE_2ADDR:
961 EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kDouble, true);
962 break;
963
964 case Instruction::DIV_DOUBLE_2ADDR:
965 EmitInsn_FPArithm(ARGS, kFPArithm_Div, kDouble, true);
966 break;
967
968 case Instruction::REM_DOUBLE_2ADDR:
969 EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kDouble, true);
970 break;
971
972 case Instruction::ADD_INT_LIT16:
973 case Instruction::ADD_INT_LIT8:
974 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Add);
975 break;
976
977 case Instruction::RSUB_INT:
978 case Instruction::RSUB_INT_LIT8:
979 EmitInsn_RSubImmediate(ARGS);
980 break;
981
982 case Instruction::MUL_INT_LIT16:
983 case Instruction::MUL_INT_LIT8:
984 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Mul);
985 break;
986
987 case Instruction::DIV_INT_LIT16:
988 case Instruction::DIV_INT_LIT8:
989 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Div);
990 break;
991
992 case Instruction::REM_INT_LIT16:
993 case Instruction::REM_INT_LIT8:
994 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Rem);
995 break;
996
997 case Instruction::AND_INT_LIT16:
998 case Instruction::AND_INT_LIT8:
999 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_And);
1000 break;
1001
1002 case Instruction::OR_INT_LIT16:
1003 case Instruction::OR_INT_LIT8:
1004 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Or);
1005 break;
1006
1007 case Instruction::XOR_INT_LIT16:
1008 case Instruction::XOR_INT_LIT8:
1009 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Xor);
1010 break;
1011
1012 case Instruction::SHL_INT_LIT8:
1013 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Shl);
1014 break;
1015
1016 case Instruction::SHR_INT_LIT8:
1017 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Shr);
1018 break;
1019
1020 case Instruction::USHR_INT_LIT8:
1021 EmitInsn_IntArithmImmediate(ARGS, kIntArithm_UShr);
1022 break;
1023
1024 case Instruction::UNUSED_3E:
1025 case Instruction::UNUSED_3F:
1026 case Instruction::UNUSED_40:
1027 case Instruction::UNUSED_41:
1028 case Instruction::UNUSED_42:
1029 case Instruction::UNUSED_43:
1030 case Instruction::UNUSED_73:
1031 case Instruction::UNUSED_79:
1032 case Instruction::UNUSED_7A:
1033 case Instruction::UNUSED_E3:
1034 case Instruction::UNUSED_E4:
1035 case Instruction::UNUSED_E5:
1036 case Instruction::UNUSED_E6:
1037 case Instruction::UNUSED_E7:
1038 case Instruction::UNUSED_E8:
1039 case Instruction::UNUSED_E9:
1040 case Instruction::UNUSED_EA:
1041 case Instruction::UNUSED_EB:
1042 case Instruction::UNUSED_EC:
1043 case Instruction::THROW_VERIFICATION_ERROR:
1044 case Instruction::UNUSED_EE:
1045 case Instruction::UNUSED_EF:
1046 case Instruction::UNUSED_F0:
1047 case Instruction::UNUSED_F1:
1048 case Instruction::UNUSED_F2:
1049 case Instruction::UNUSED_F3:
1050 case Instruction::UNUSED_F4:
1051 case Instruction::UNUSED_F5:
1052 case Instruction::UNUSED_F6:
1053 case Instruction::UNUSED_F7:
1054 case Instruction::UNUSED_F8:
1055 case Instruction::UNUSED_F9:
1056 case Instruction::UNUSED_FA:
1057 case Instruction::UNUSED_FB:
1058 case Instruction::UNUSED_FC:
1059 case Instruction::UNUSED_FD:
1060 case Instruction::UNUSED_FE:
1061 case Instruction::UNUSED_FF:
1062 LOG(FATAL) << "Dex file contains UNUSED bytecode: " << insn->Opcode();
1063 break;
1064 }
1065
1066#undef ARGS
1067}
1068
1069
1070void MethodCompiler::EmitInsn_Nop(uint32_t dex_pc,
1071 Instruction const* insn) {
Logan Chiene09a6b72011-12-27 17:50:21 +08001072
1073 uint16_t insn_signature = code_item_->insns_[dex_pc];
1074
1075 if (insn_signature == Instruction::kPackedSwitchSignature ||
1076 insn_signature == Instruction::kSparseSwitchSignature ||
1077 insn_signature == Instruction::kArrayDataSignature) {
1078 irb_.CreateUnreachable();
1079 } else{
1080 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1081 }
Shih-wei Liaod1fec812012-02-13 09:51:10 -08001082}
1083
1084
Logan Chien70f94b42011-12-27 17:49:11 +08001085void MethodCompiler::EmitInsn_Move(uint32_t dex_pc,
1086 Instruction const* insn,
1087 JType jty) {
Logan Chien48173132011-12-27 17:51:13 +08001088
1089 Instruction::DecodedInstruction dec_insn(insn);
1090
1091 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, jty, kReg);
1092 EmitStoreDalvikReg(dec_insn.vA_, jty, kReg, src_value);
1093
Logan Chien70f94b42011-12-27 17:49:11 +08001094 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1095}
1096
1097
1098void MethodCompiler::EmitInsn_MoveResult(uint32_t dex_pc,
1099 Instruction const* insn,
1100 JType jty) {
Logan Chien48173132011-12-27 17:51:13 +08001101
1102 Instruction::DecodedInstruction dec_insn(insn);
1103
1104 llvm::Value* src_value = EmitLoadDalvikRetValReg(jty, kReg);
1105 EmitStoreDalvikReg(dec_insn.vA_, jty, kReg, src_value);
1106
Logan Chien70f94b42011-12-27 17:49:11 +08001107 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1108}
1109
1110
1111void MethodCompiler::EmitInsn_MoveException(uint32_t dex_pc,
1112 Instruction const* insn) {
Logan Chien3354cec2012-01-13 14:29:03 +08001113
1114 Instruction::DecodedInstruction dec_insn(insn);
1115
1116 // Get thread-local exception field address
1117 llvm::Constant* exception_field_offset =
1118 irb_.getPtrEquivInt(Thread::ExceptionOffset().Int32Value());
1119
1120 llvm::Value* thread_object_addr =
1121 irb_.CreateCall(irb_.GetRuntime(GetCurrentThread));
1122
1123 llvm::Value* exception_field_addr =
1124 irb_.CreatePtrDisp(thread_object_addr, exception_field_offset,
1125 irb_.getJObjectTy()->getPointerTo());
1126
1127 // Get exception object address
1128 llvm::Value* exception_object_addr = irb_.CreateLoad(exception_field_addr);
1129
1130 // Set thread-local exception field address to NULL
1131 irb_.CreateStore(irb_.getJNull(), exception_field_addr);
1132
1133 // Keep the exception object in the Dalvik register
1134 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, exception_object_addr);
1135
Logan Chien70f94b42011-12-27 17:49:11 +08001136 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1137}
1138
1139
1140void MethodCompiler::EmitInsn_ThrowException(uint32_t dex_pc,
1141 Instruction const* insn) {
Logan Chien6c6f12d2012-01-13 19:26:27 +08001142
1143 Instruction::DecodedInstruction dec_insn(insn);
1144
1145 llvm::Value* exception_addr =
1146 EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1147
1148 irb_.CreateCall(irb_.GetRuntime(ThrowException), exception_addr);
1149
1150 EmitBranchExceptionLandingPad(dex_pc);
Logan Chien70f94b42011-12-27 17:49:11 +08001151}
1152
1153
1154void MethodCompiler::EmitInsn_ReturnVoid(uint32_t dex_pc,
1155 Instruction const* insn) {
Logan Chien8898a272011-12-27 17:51:56 +08001156 // Garbage collection safe-point
1157 EmitGuard_GarbageCollectionSuspend(dex_pc);
1158
1159 // Return!
1160 irb_.CreateRetVoid();
Logan Chien70f94b42011-12-27 17:49:11 +08001161}
1162
1163
1164void MethodCompiler::EmitInsn_Return(uint32_t dex_pc,
1165 Instruction const* insn) {
Logan Chien8898a272011-12-27 17:51:56 +08001166
1167 Instruction::DecodedInstruction dec_insn(insn);
1168
1169 // Garbage collection safe-point
1170 EmitGuard_GarbageCollectionSuspend(dex_pc);
1171
1172 // Return!
1173 char ret_shorty = method_helper_.GetShorty()[0];
1174 llvm::Value* retval = EmitLoadDalvikReg(dec_insn.vA_, ret_shorty, kAccurate);
1175
1176 irb_.CreateRet(retval);
Logan Chien70f94b42011-12-27 17:49:11 +08001177}
1178
1179
1180void MethodCompiler::EmitInsn_LoadConstant(uint32_t dex_pc,
1181 Instruction const* insn,
1182 JType imm_jty) {
Shih-wei Liao798366e2012-02-16 09:25:33 -08001183
1184 Instruction::DecodedInstruction dec_insn(insn);
1185
1186 DCHECK(imm_jty == kInt || imm_jty == kLong) << imm_jty;
1187
1188 int64_t imm = 0;
1189
1190 switch (insn->Opcode()) {
1191 // 32-bit Immediate
1192 case Instruction::CONST_4:
1193 case Instruction::CONST_16:
1194 case Instruction::CONST:
1195 case Instruction::CONST_WIDE_16:
1196 case Instruction::CONST_WIDE_32:
1197 imm = static_cast<int64_t>(static_cast<int32_t>(dec_insn.vB_));
1198 break;
1199
1200 case Instruction::CONST_HIGH16:
1201 imm = static_cast<int64_t>(static_cast<int32_t>(
1202 static_cast<uint32_t>(static_cast<uint16_t>(dec_insn.vB_)) << 16));
1203 break;
1204
1205 // 64-bit Immediate
1206 case Instruction::CONST_WIDE:
1207 imm = static_cast<int64_t>(dec_insn.vB_wide_);
1208 break;
1209
1210 case Instruction::CONST_WIDE_HIGH16:
1211 imm = static_cast<int64_t>(
1212 static_cast<uint64_t>(static_cast<uint16_t>(dec_insn.vB_)) << 48);
1213 break;
1214
1215 // Unknown opcode for load constant (unreachable)
1216 default:
1217 LOG(FATAL) << "Unknown opcode for load constant: " << insn->Opcode();
1218 break;
1219 }
1220
1221 // Store the non-object register
1222 llvm::Type* imm_type = irb_.getJType(imm_jty, kAccurate);
1223 llvm::Constant* imm_value = llvm::ConstantInt::getSigned(imm_type, imm);
1224 EmitStoreDalvikReg(dec_insn.vA_, imm_jty, kAccurate, imm_value);
1225
1226 // Store the object register if it is possible to be null.
1227 if (imm_jty == kInt && imm == 0) {
1228 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, irb_.getJNull());
1229 }
1230
Logan Chien70f94b42011-12-27 17:49:11 +08001231 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1232}
1233
1234
1235void MethodCompiler::EmitInsn_LoadConstantString(uint32_t dex_pc,
1236 Instruction const* insn) {
1237 // UNIMPLEMENTED(WARNING);
1238 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1239}
1240
1241
Logan Chien27b30252012-01-14 03:43:35 +08001242llvm::Value* MethodCompiler::EmitLoadConstantClass(uint32_t dex_pc,
1243 uint32_t type_idx) {
1244 if (!compiler_->CanAccessTypeWithoutChecks(method_idx_, dex_cache_,
1245 *dex_file_, type_idx)) {
1246 llvm::Value* type_idx_value = irb_.getInt32(type_idx);
1247
1248 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
1249
1250 llvm::Function* runtime_func =
1251 irb_.GetRuntime(InitializeTypeAndVerifyAccess);
1252
1253 llvm::Value* type_object_addr =
1254 irb_.CreateCall2(runtime_func, type_idx_value, method_object_addr);
1255
1256 EmitGuard_ExceptionLandingPad(dex_pc);
1257
1258 return type_object_addr;
1259
1260 } else {
1261 // Try to load the class (type) object from the test cache.
1262 llvm::Value* type_field_addr =
1263 EmitLoadDexCacheResolvedTypeFieldAddr(type_idx);
1264
1265 llvm::Value* type_object_addr = irb_.CreateLoad(type_field_addr);
1266
1267 if (compiler_->CanAssumeTypeIsPresentInDexCache(dex_cache_, type_idx)) {
1268 return type_object_addr;
1269 }
1270
1271 llvm::BasicBlock* block_original = irb_.GetInsertBlock();
1272
1273 // Test whether class (type) object is in the dex cache or not
1274 llvm::Value* equal_null =
1275 irb_.CreateICmpEQ(type_object_addr, irb_.getJNull());
1276
1277 llvm::BasicBlock* block_cont =
1278 CreateBasicBlockWithDexPC(dex_pc, "cont");
1279
1280 llvm::BasicBlock* block_load_class =
1281 CreateBasicBlockWithDexPC(dex_pc, "load_class");
1282
1283 irb_.CreateCondBr(equal_null, block_load_class, block_cont);
1284
1285 // Failback routine to load the class object
1286 irb_.SetInsertPoint(block_load_class);
1287
1288 llvm::Function* runtime_func = irb_.GetRuntime(InitializeType);
1289
1290 llvm::Constant* type_idx_value = irb_.getInt32(type_idx);
1291
1292 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
1293
1294 llvm::Value* loaded_type_object_addr =
1295 irb_.CreateCall2(runtime_func, type_idx_value, method_object_addr);
1296
1297 EmitGuard_ExceptionLandingPad(dex_pc);
1298
1299 llvm::BasicBlock* block_after_load_class = irb_.GetInsertBlock();
1300
1301 irb_.CreateBr(block_cont);
1302
1303 // Now the class object must be loaded
1304 irb_.SetInsertPoint(block_cont);
1305
1306 llvm::PHINode* phi = irb_.CreatePHI(irb_.getJObjectTy(), 2);
1307
1308 phi->addIncoming(type_object_addr, block_original);
1309 phi->addIncoming(loaded_type_object_addr, block_after_load_class);
1310
1311 return phi;
1312 }
1313}
1314
1315
Logan Chien70f94b42011-12-27 17:49:11 +08001316void MethodCompiler::EmitInsn_LoadConstantClass(uint32_t dex_pc,
1317 Instruction const* insn) {
Logan Chien27b30252012-01-14 03:43:35 +08001318
1319 Instruction::DecodedInstruction dec_insn(insn);
1320
1321 llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vB_);
1322 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, type_object_addr);
1323
Logan Chien70f94b42011-12-27 17:49:11 +08001324 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1325}
1326
1327
1328void MethodCompiler::EmitInsn_MonitorEnter(uint32_t dex_pc,
1329 Instruction const* insn) {
Logan Chien9e0dbe42012-01-13 12:11:37 +08001330
1331 Instruction::DecodedInstruction dec_insn(insn);
1332
1333 llvm::Value* object_addr =
1334 EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1335
1336 // TODO: Slow path always. May not need NullPointerException check.
1337 EmitGuard_NullPointerException(dex_pc, object_addr);
1338
1339 irb_.CreateCall(irb_.GetRuntime(LockObject), object_addr);
1340 EmitGuard_ExceptionLandingPad(dex_pc);
1341
Logan Chien70f94b42011-12-27 17:49:11 +08001342 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1343}
1344
1345
1346void MethodCompiler::EmitInsn_MonitorExit(uint32_t dex_pc,
1347 Instruction const* insn) {
Logan Chien9e0dbe42012-01-13 12:11:37 +08001348
1349 Instruction::DecodedInstruction dec_insn(insn);
1350
1351 llvm::Value* object_addr =
1352 EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1353
1354 EmitGuard_NullPointerException(dex_pc, object_addr);
1355
1356 irb_.CreateCall(irb_.GetRuntime(UnlockObject), object_addr);
1357 EmitGuard_ExceptionLandingPad(dex_pc);
1358
Logan Chien70f94b42011-12-27 17:49:11 +08001359 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1360}
1361
1362
1363void MethodCompiler::EmitInsn_CheckCast(uint32_t dex_pc,
1364 Instruction const* insn) {
Logan Chienfc880952012-01-15 23:53:10 +08001365
1366 Instruction::DecodedInstruction dec_insn(insn);
1367
1368 llvm::BasicBlock* block_test_class =
1369 CreateBasicBlockWithDexPC(dex_pc, "test_class");
1370
1371 llvm::BasicBlock* block_test_sub_class =
1372 CreateBasicBlockWithDexPC(dex_pc, "test_sub_class");
1373
1374 llvm::Value* object_addr =
1375 EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1376
1377 // Test: Is the reference equal to null? Act as no-op when it is null.
1378 llvm::Value* equal_null = irb_.CreateICmpEQ(object_addr, irb_.getJNull());
1379
1380 irb_.CreateCondBr(equal_null,
1381 GetNextBasicBlock(dex_pc),
1382 block_test_class);
1383
1384 // Test: Is the object instantiated from the given class?
1385 irb_.SetInsertPoint(block_test_class);
1386 llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vB_);
1387 DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
1388
1389 llvm::PointerType* jobject_ptr_ty = irb_.getJObjectTy();
1390
1391 llvm::Value* object_type_field_addr =
1392 irb_.CreateBitCast(object_addr, jobject_ptr_ty->getPointerTo());
1393
1394 llvm::Value* object_type_object_addr =
1395 irb_.CreateLoad(object_type_field_addr);
1396
1397 llvm::Value* equal_class =
1398 irb_.CreateICmpEQ(type_object_addr, object_type_object_addr);
1399
1400 irb_.CreateCondBr(equal_class,
1401 GetNextBasicBlock(dex_pc),
1402 block_test_sub_class);
1403
1404 // Test: Is the object instantiated from the subclass of the given class?
1405 irb_.SetInsertPoint(block_test_sub_class);
1406
1407 irb_.CreateCall2(irb_.GetRuntime(CheckCast),
1408 type_object_addr, object_type_object_addr);
1409
1410 EmitGuard_ExceptionLandingPad(dex_pc);
1411
Logan Chien70f94b42011-12-27 17:49:11 +08001412 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1413}
1414
1415
1416void MethodCompiler::EmitInsn_InstanceOf(uint32_t dex_pc,
1417 Instruction const* insn) {
Logan Chien68725e22012-01-15 22:25:34 +08001418
1419 Instruction::DecodedInstruction dec_insn(insn);
1420
1421 llvm::Constant* zero = irb_.getJInt(0);
1422 llvm::Constant* one = irb_.getJInt(1);
1423
1424 llvm::BasicBlock* block_nullp = CreateBasicBlockWithDexPC(dex_pc, "nullp");
1425
1426 llvm::BasicBlock* block_test_class =
1427 CreateBasicBlockWithDexPC(dex_pc, "test_class");
1428
1429 llvm::BasicBlock* block_class_equals =
1430 CreateBasicBlockWithDexPC(dex_pc, "class_eq");
1431
1432 llvm::BasicBlock* block_test_sub_class =
1433 CreateBasicBlockWithDexPC(dex_pc, "test_sub_class");
1434
1435 llvm::Value* object_addr =
1436 EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
1437
1438 // Overview of the following code :
1439 // We check for null, if so, then false, otherwise check for class == . If so
1440 // then true, otherwise do callout slowpath.
1441 //
1442 // Test: Is the reference equal to null? Set 0 when it is null.
1443 llvm::Value* equal_null = irb_.CreateICmpEQ(object_addr, irb_.getJNull());
1444
1445 irb_.CreateCondBr(equal_null, block_nullp, block_test_class);
1446
1447 irb_.SetInsertPoint(block_nullp);
1448 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, zero);
1449 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1450
1451 // Test: Is the object instantiated from the given class?
1452 irb_.SetInsertPoint(block_test_class);
1453 llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vC_);
1454 DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
1455
1456 llvm::PointerType* jobject_ptr_ty = irb_.getJObjectTy();
1457
1458 llvm::Value* object_type_field_addr =
1459 irb_.CreateBitCast(object_addr, jobject_ptr_ty->getPointerTo());
1460
1461 llvm::Value* object_type_object_addr =
1462 irb_.CreateLoad(object_type_field_addr);
1463
1464 llvm::Value* equal_class =
1465 irb_.CreateICmpEQ(type_object_addr, object_type_object_addr);
1466
1467 irb_.CreateCondBr(equal_class, block_class_equals, block_test_sub_class);
1468
1469 irb_.SetInsertPoint(block_class_equals);
1470 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, one);
1471 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1472
1473 // Test: Is the object instantiated from the subclass of the given class?
1474 irb_.SetInsertPoint(block_test_sub_class);
1475
1476 llvm::Value* result =
1477 irb_.CreateCall2(irb_.GetRuntime(IsAssignable),
1478 type_object_addr, object_type_object_addr);
1479
1480 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
1481
Logan Chien70f94b42011-12-27 17:49:11 +08001482 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1483}
1484
1485
Logan Chien61bb6142012-02-03 15:34:53 +08001486llvm::Value* MethodCompiler::EmitLoadArrayLength(llvm::Value* array) {
1487 // Load array length field address
1488 llvm::Constant* array_len_field_offset =
1489 irb_.getPtrEquivInt(Array::LengthOffset().Int32Value());
1490
1491 llvm::Value* array_len_field_addr =
1492 irb_.CreatePtrDisp(array, array_len_field_offset,
1493 irb_.getJIntTy()->getPointerTo());
1494
1495 // Load array length
1496 return irb_.CreateLoad(array_len_field_addr);
1497}
1498
1499
Logan Chien70f94b42011-12-27 17:49:11 +08001500void MethodCompiler::EmitInsn_ArrayLength(uint32_t dex_pc,
1501 Instruction const* insn) {
Logan Chien61bb6142012-02-03 15:34:53 +08001502
1503 Instruction::DecodedInstruction dec_insn(insn);
1504
1505 // Get the array object address
1506 llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
1507 EmitGuard_NullPointerException(dex_pc, array_addr);
1508
1509 // Get the array length and store it to the register
1510 llvm::Value* array_len = EmitLoadArrayLength(array_addr);
1511 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, array_len);
1512
Logan Chien70f94b42011-12-27 17:49:11 +08001513 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1514}
1515
1516
1517void MethodCompiler::EmitInsn_NewInstance(uint32_t dex_pc,
1518 Instruction const* insn) {
Logan Chien032bdad2012-01-16 09:59:23 +08001519
1520 Instruction::DecodedInstruction dec_insn(insn);
1521
1522 llvm::Function* runtime_func;
1523 if (compiler_->CanAccessTypeWithoutChecks(method_idx_, dex_cache_,
1524 *dex_file_, dec_insn.vB_)) {
1525 runtime_func = irb_.GetRuntime(AllocObject);
1526 } else {
1527 runtime_func = irb_.GetRuntime(AllocObjectWithAccessCheck);
1528 }
1529
1530 llvm::Constant* type_index_value = irb_.getInt32(dec_insn.vB_);
1531
1532 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
1533
1534 llvm::Value* object_addr =
1535 irb_.CreateCall2(runtime_func, type_index_value, method_object_addr);
1536
1537 EmitGuard_ExceptionLandingPad(dex_pc);
1538
1539 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, object_addr);
1540
Logan Chien70f94b42011-12-27 17:49:11 +08001541 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1542}
1543
1544
Logan Chiena2cc6a32012-01-16 10:38:41 +08001545llvm::Value* MethodCompiler::EmitAllocNewArray(uint32_t dex_pc,
1546 int32_t length,
1547 uint32_t type_idx,
1548 bool is_filled_new_array) {
1549 llvm::Function* runtime_func;
1550
1551 bool skip_access_check =
1552 compiler_->CanAccessTypeWithoutChecks(method_idx_, dex_cache_,
1553 *dex_file_, type_idx);
1554
1555 if (is_filled_new_array) {
1556 runtime_func = skip_access_check ?
1557 irb_.GetRuntime(CheckAndAllocArray) :
1558 irb_.GetRuntime(CheckAndAllocArrayWithAccessCheck);
1559 } else {
1560 runtime_func = skip_access_check ?
1561 irb_.GetRuntime(AllocArray) :
1562 irb_.GetRuntime(AllocArrayWithAccessCheck);
1563 }
1564
1565 llvm::Constant* type_index_value = irb_.getInt32(type_idx);
1566
1567 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
1568
1569 llvm::Value* array_length_value = irb_.getInt32(length);
1570
1571 llvm::Value* object_addr =
1572 irb_.CreateCall3(runtime_func, type_index_value, method_object_addr,
1573 array_length_value);
1574
1575 EmitGuard_ExceptionLandingPad(dex_pc);
1576
1577 return object_addr;
1578}
1579
1580
Logan Chien70f94b42011-12-27 17:49:11 +08001581void MethodCompiler::EmitInsn_NewArray(uint32_t dex_pc,
1582 Instruction const* insn) {
Logan Chiena2cc6a32012-01-16 10:38:41 +08001583
1584 Instruction::DecodedInstruction dec_insn(insn);
1585
1586 llvm::Value* object_addr =
1587 EmitAllocNewArray(dex_pc, dec_insn.vB_, dec_insn.vC_, false);
1588
1589 EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, object_addr);
1590
Logan Chien70f94b42011-12-27 17:49:11 +08001591 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1592}
1593
1594
1595void MethodCompiler::EmitInsn_FilledNewArray(uint32_t dex_pc,
1596 Instruction const* insn,
1597 bool is_range) {
Logan Chiena85fb2f2012-01-16 12:52:56 +08001598
1599 Instruction::DecodedInstruction dec_insn(insn);
1600
1601 llvm::Value* object_addr =
1602 EmitAllocNewArray(dex_pc, dec_insn.vA_, dec_insn.vB_, true);
1603
1604 if (dec_insn.vA_ > 0) {
1605 llvm::Value* object_addr_int =
1606 irb_.CreatePtrToInt(object_addr, irb_.getPtrEquivIntTy());
1607
1608 llvm::Value* data_field_offset =
1609 irb_.getPtrEquivInt(Array::DataOffset().Int32Value());
1610
1611 llvm::Value* data_field_addr_int =
1612 irb_.CreateAdd(object_addr_int, data_field_offset);
1613
1614 Class* klass = method_->GetDexCacheResolvedTypes()->Get(dec_insn.vB_);
1615 CHECK_NE(klass, static_cast<Class*>(NULL));
1616 // Moved this below already: CHECK(!klass->IsPrimitive() || klass->IsPrimitiveInt());
1617
1618 llvm::Constant* word_size = irb_.getSizeOfPtrEquivIntValue();
1619
1620 llvm::Type* field_type;
1621 if (klass->IsPrimitiveInt()) {
1622 field_type = irb_.getJIntTy()->getPointerTo();
1623 } else {
1624 CHECK(!klass->IsPrimitive());
1625 field_type = irb_.getJObjectTy()->getPointerTo();
1626 }
1627
1628 // TODO: Tune this code. Currently we are generating one instruction for
1629 // one element which may be very space consuming. Maybe changing to use
1630 // memcpy may help; however, since we can't guarantee that the alloca of
1631 // dalvik register are continuous, we can't perform such optimization yet.
1632 for (uint32_t i = 0; i < dec_insn.vA_; ++i) {
1633 llvm::Value* data_field_addr =
1634 irb_.CreateIntToPtr(data_field_addr_int, field_type);
1635
1636 int reg_index;
1637 if (is_range) {
1638 reg_index = dec_insn.vC_ + i;
1639 } else {
1640 reg_index = dec_insn.arg_[i];
1641 }
1642
1643 llvm::Value* reg_value;
1644 if (klass->IsPrimitiveInt()) {
1645 reg_value = EmitLoadDalvikReg(reg_index, kInt, kAccurate);
1646 } else {
1647 reg_value = EmitLoadDalvikReg(reg_index, kObject, kAccurate);
1648 }
1649
1650 irb_.CreateStore(reg_value, data_field_addr);
1651
1652 data_field_addr_int = irb_.CreateAdd(data_field_addr_int, word_size);
1653 }
1654 }
1655
1656 EmitStoreDalvikRetValReg(kObject, kAccurate, object_addr);
1657
Logan Chien70f94b42011-12-27 17:49:11 +08001658 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1659}
1660
1661
1662void MethodCompiler::EmitInsn_FillArrayData(uint32_t dex_pc,
1663 Instruction const* insn) {
1664 // UNIMPLEMENTED(WARNING);
1665 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1666}
1667
1668
1669void MethodCompiler::EmitInsn_UnconditionalBranch(uint32_t dex_pc,
1670 Instruction const* insn) {
Logan Chiena466c162011-12-27 17:55:46 +08001671
1672 Instruction::DecodedInstruction dec_insn(insn);
1673
1674 int32_t branch_offset = dec_insn.vA_;
1675
1676 if (branch_offset <= 0) {
1677 // Garbage collection safe-point on backward branch
1678 EmitGuard_GarbageCollectionSuspend(dex_pc);
1679 }
1680
1681 irb_.CreateBr(GetBasicBlock(dex_pc + branch_offset));
Logan Chien70f94b42011-12-27 17:49:11 +08001682}
1683
1684
1685void MethodCompiler::EmitInsn_PackedSwitch(uint32_t dex_pc,
1686 Instruction const* insn) {
Logan Chien7a89b6d2011-12-27 17:56:56 +08001687
1688 Instruction::DecodedInstruction dec_insn(insn);
1689
1690 struct PACKED Payload {
1691 uint16_t ident_;
1692 uint16_t num_cases_;
1693 int32_t first_key_;
1694 int32_t targets_[];
1695 };
1696
1697 int32_t payload_offset = static_cast<int32_t>(dex_pc) +
1698 static_cast<int32_t>(dec_insn.vB_);
1699
1700 Payload const* payload =
1701 reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
1702
1703 llvm::Value* value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
1704
1705 llvm::SwitchInst* sw =
1706 irb_.CreateSwitch(value, GetNextBasicBlock(dex_pc), payload->num_cases_);
1707
1708 for (uint16_t i = 0; i < payload->num_cases_; ++i) {
1709 sw->addCase(irb_.getInt32(payload->first_key_ + i),
1710 GetBasicBlock(dex_pc + payload->targets_[i]));
1711 }
Logan Chien70f94b42011-12-27 17:49:11 +08001712}
1713
1714
1715void MethodCompiler::EmitInsn_SparseSwitch(uint32_t dex_pc,
1716 Instruction const* insn) {
Logan Chien7a89b6d2011-12-27 17:56:56 +08001717
1718 Instruction::DecodedInstruction dec_insn(insn);
1719
1720 struct PACKED Payload {
1721 uint16_t ident_;
1722 uint16_t num_cases_;
1723 int32_t keys_and_targets_[];
1724 };
1725
1726 int32_t payload_offset = static_cast<int32_t>(dex_pc) +
1727 static_cast<int32_t>(dec_insn.vB_);
1728
1729 Payload const* payload =
1730 reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
1731
1732 int32_t const* keys = payload->keys_and_targets_;
1733 int32_t const* targets = payload->keys_and_targets_ + payload->num_cases_;
1734
1735 llvm::Value* value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
1736
1737 llvm::SwitchInst* sw =
1738 irb_.CreateSwitch(value, GetNextBasicBlock(dex_pc), payload->num_cases_);
1739
1740 for (size_t i = 0; i < payload->num_cases_; ++i) {
1741 sw->addCase(irb_.getInt32(keys[i]), GetBasicBlock(dex_pc + targets[i]));
1742 }
Logan Chien70f94b42011-12-27 17:49:11 +08001743}
1744
1745
1746void MethodCompiler::EmitInsn_FPCompare(uint32_t dex_pc,
1747 Instruction const* insn,
1748 JType fp_jty,
1749 bool gt_bias) {
Logan Chien2c37e8e2011-12-27 17:58:46 +08001750
1751 Instruction::DecodedInstruction dec_insn(insn);
1752
1753 DCHECK(fp_jty == kFloat || fp_jty == kDouble) << "JType: " << fp_jty;
1754
1755 llvm::Value* src1_value = EmitLoadDalvikReg(dec_insn.vB_, fp_jty, kAccurate);
1756 llvm::Value* src2_value = EmitLoadDalvikReg(dec_insn.vC_, fp_jty, kAccurate);
1757
1758 llvm::Value* cmp_eq = irb_.CreateFCmpOEQ(src1_value, src2_value);
1759 llvm::Value* cmp_lt;
1760
1761 if (gt_bias) {
1762 cmp_lt = irb_.CreateFCmpOLT(src1_value, src2_value);
1763 } else {
1764 cmp_lt = irb_.CreateFCmpULT(src1_value, src2_value);
1765 }
1766
1767 llvm::Value* result = EmitCompareResultSelection(cmp_eq, cmp_lt);
1768 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
1769
Logan Chien70f94b42011-12-27 17:49:11 +08001770 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1771}
1772
1773
1774void MethodCompiler::EmitInsn_LongCompare(uint32_t dex_pc,
1775 Instruction const* insn) {
Logan Chien2c37e8e2011-12-27 17:58:46 +08001776
1777 Instruction::DecodedInstruction dec_insn(insn);
1778
1779 llvm::Value* src1_value = EmitLoadDalvikReg(dec_insn.vB_, kLong, kAccurate);
1780 llvm::Value* src2_value = EmitLoadDalvikReg(dec_insn.vC_, kLong, kAccurate);
1781
1782 llvm::Value* cmp_eq = irb_.CreateICmpEQ(src1_value, src2_value);
1783 llvm::Value* cmp_lt = irb_.CreateICmpSLT(src1_value, src2_value);
1784
1785 llvm::Value* result = EmitCompareResultSelection(cmp_eq, cmp_lt);
1786 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
1787
Logan Chien70f94b42011-12-27 17:49:11 +08001788 irb_.CreateBr(GetNextBasicBlock(dex_pc));
1789}
1790
1791
Logan Chien2c37e8e2011-12-27 17:58:46 +08001792llvm::Value* MethodCompiler::EmitCompareResultSelection(llvm::Value* cmp_eq,
1793 llvm::Value* cmp_lt) {
1794
1795 llvm::Constant* zero = irb_.getJInt(0);
1796 llvm::Constant* pos1 = irb_.getJInt(1);
1797 llvm::Constant* neg1 = irb_.getJInt(-1);
1798
1799 llvm::Value* result_lt = irb_.CreateSelect(cmp_lt, neg1, pos1);
1800 llvm::Value* result_eq = irb_.CreateSelect(cmp_eq, zero, result_lt);
1801
1802 return result_eq;
1803}
1804
1805
Logan Chien70f94b42011-12-27 17:49:11 +08001806void MethodCompiler::EmitInsn_BinaryConditionalBranch(uint32_t dex_pc,
1807 Instruction const* insn,
1808 CondBranchKind cond) {
Logan Chiena78e3c82011-12-27 17:59:35 +08001809
1810 Instruction::DecodedInstruction dec_insn(insn);
1811
1812 int8_t src1_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA_);
1813 int8_t src2_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vB_);
1814
1815 DCHECK_NE(kRegUnknown, src1_reg_cat);
1816 DCHECK_NE(kRegUnknown, src2_reg_cat);
1817 DCHECK_NE(kRegCat2, src1_reg_cat);
1818 DCHECK_NE(kRegCat2, src2_reg_cat);
1819
1820 int32_t branch_offset = dec_insn.vC_;
1821
1822 if (branch_offset <= 0) {
1823 // Garbage collection safe-point on backward branch
1824 EmitGuard_GarbageCollectionSuspend(dex_pc);
1825 }
1826
1827 if (src1_reg_cat == kRegZero && src2_reg_cat == kRegZero) {
1828 irb_.CreateBr(GetBasicBlock(dex_pc + branch_offset));
1829 return;
1830 }
1831
1832 llvm::Value* src1_value;
1833 llvm::Value* src2_value;
1834
1835 if (src1_reg_cat != kRegZero && src2_reg_cat != kRegZero) {
1836 CHECK_EQ(src1_reg_cat, src2_reg_cat);
1837
1838 if (src1_reg_cat == kRegCat1nr) {
1839 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
1840 src2_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
1841 } else {
1842 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1843 src2_value = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
1844 }
1845 } else {
1846 DCHECK(src1_reg_cat == kRegZero ||
1847 src2_reg_cat == kRegZero);
1848
1849 if (src1_reg_cat == kRegZero) {
1850 if (src2_reg_cat == kRegCat1nr) {
1851 src1_value = irb_.getJInt(0);
1852 src2_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
1853 } else {
1854 src1_value = irb_.getJNull();
1855 src2_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1856 }
1857 } else { // src2_reg_cat == kRegZero
1858 if (src2_reg_cat == kRegCat1nr) {
1859 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
1860 src2_value = irb_.getJInt(0);
1861 } else {
1862 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1863 src2_value = irb_.getJNull();
1864 }
1865 }
1866 }
1867
1868 llvm::Value* cond_value =
1869 EmitConditionResult(src1_value, src2_value, cond);
1870
1871 irb_.CreateCondBr(cond_value,
1872 GetBasicBlock(dex_pc + branch_offset),
1873 GetNextBasicBlock(dex_pc));
Logan Chien70f94b42011-12-27 17:49:11 +08001874}
1875
1876
1877void MethodCompiler::EmitInsn_UnaryConditionalBranch(uint32_t dex_pc,
1878 Instruction const* insn,
1879 CondBranchKind cond) {
Logan Chiena78e3c82011-12-27 17:59:35 +08001880
1881 Instruction::DecodedInstruction dec_insn(insn);
1882
1883 int8_t src_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA_);
1884
1885 DCHECK_NE(kRegUnknown, src_reg_cat);
1886 DCHECK_NE(kRegCat2, src_reg_cat);
1887
1888 int32_t branch_offset = dec_insn.vB_;
1889
1890 if (branch_offset <= 0) {
1891 // Garbage collection safe-point on backward branch
1892 EmitGuard_GarbageCollectionSuspend(dex_pc);
1893 }
1894
1895 if (src_reg_cat == kRegZero) {
1896 irb_.CreateBr(GetBasicBlock(dex_pc + branch_offset));
1897 return;
1898 }
1899
1900 llvm::Value* src1_value;
1901 llvm::Value* src2_value;
1902
1903 if (src_reg_cat == kRegCat1nr) {
1904 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
1905 src2_value = irb_.getInt32(0);
1906 } else {
1907 src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
1908 src2_value = irb_.getJNull();
1909 }
1910
1911 llvm::Value* cond_value =
1912 EmitConditionResult(src1_value, src2_value, cond);
1913
1914 irb_.CreateCondBr(cond_value,
1915 GetBasicBlock(dex_pc + branch_offset),
1916 GetNextBasicBlock(dex_pc));
1917}
1918
1919
1920RegCategory MethodCompiler::GetInferredRegCategory(uint32_t dex_pc,
1921 uint16_t reg_idx) {
1922 InferredRegCategoryMap const* map = method_->GetInferredRegCategoryMap();
1923 CHECK_NE(map, static_cast<InferredRegCategoryMap*>(NULL));
1924
1925 return map->GetRegCategory(dex_pc, reg_idx);
1926}
1927
1928
1929llvm::Value* MethodCompiler::EmitConditionResult(llvm::Value* lhs,
1930 llvm::Value* rhs,
1931 CondBranchKind cond) {
1932 switch (cond) {
1933 case kCondBranch_EQ:
1934 return irb_.CreateICmpEQ(lhs, rhs);
1935
1936 case kCondBranch_NE:
1937 return irb_.CreateICmpNE(lhs, rhs);
1938
1939 case kCondBranch_LT:
1940 return irb_.CreateICmpSLT(lhs, rhs);
1941
1942 case kCondBranch_GE:
1943 return irb_.CreateICmpSGE(lhs, rhs);
1944
1945 case kCondBranch_GT:
1946 return irb_.CreateICmpSGT(lhs, rhs);
1947
1948 case kCondBranch_LE:
1949 return irb_.CreateICmpSLE(lhs, rhs);
1950
1951 default: // Unreachable
1952 LOG(FATAL) << "Unknown conditional branch kind: " << cond;
1953 return NULL;
1954 }
Logan Chien70f94b42011-12-27 17:49:11 +08001955}
1956
1957
Logan Chiene27fdbb2012-01-02 23:27:26 +08001958void
1959MethodCompiler::EmitGuard_ArrayIndexOutOfBoundsException(uint32_t dex_pc,
1960 llvm::Value* array,
1961 llvm::Value* index) {
1962 llvm::Value* array_len = EmitLoadArrayLength(array);
1963
1964 llvm::Value* cmp = irb_.CreateICmpUGE(index, array_len);
1965
1966 llvm::BasicBlock* block_exception =
1967 CreateBasicBlockWithDexPC(dex_pc, "overflow");
1968
1969 llvm::BasicBlock* block_continue =
1970 CreateBasicBlockWithDexPC(dex_pc, "cont");
1971
1972 irb_.CreateCondBr(cmp, block_exception, block_continue);
1973
1974 irb_.SetInsertPoint(block_exception);
1975 irb_.CreateCall2(irb_.GetRuntime(ThrowIndexOutOfBounds), index, array_len);
1976 EmitBranchExceptionLandingPad(dex_pc);
1977
1978 irb_.SetInsertPoint(block_continue);
1979}
1980
1981
1982void MethodCompiler::EmitGuard_ArrayException(uint32_t dex_pc,
1983 llvm::Value* array,
1984 llvm::Value* index) {
1985 EmitGuard_NullPointerException(dex_pc, array);
1986 EmitGuard_ArrayIndexOutOfBoundsException(dex_pc, array, index);
1987}
1988
1989
1990// Emit Array GetElementPtr
1991llvm::Value* MethodCompiler::EmitArrayGEP(llvm::Value* array_addr,
1992 llvm::Value* index_value,
1993 llvm::Type* elem_type) {
1994
1995 llvm::Constant* data_offset_value =
1996 irb_.getPtrEquivInt(Array::DataOffset().Int32Value());
1997
1998 llvm::Value* array_data_addr =
1999 irb_.CreatePtrDisp(array_addr, data_offset_value,
2000 elem_type->getPointerTo());
2001
2002 return irb_.CreateGEP(array_data_addr, index_value);
2003}
2004
2005
Logan Chien70f94b42011-12-27 17:49:11 +08002006void MethodCompiler::EmitInsn_AGet(uint32_t dex_pc,
2007 Instruction const* insn,
2008 JType elem_jty) {
Logan Chiene27fdbb2012-01-02 23:27:26 +08002009
2010 Instruction::DecodedInstruction dec_insn(insn);
2011
2012 llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
2013 llvm::Value* index_value = EmitLoadDalvikReg(dec_insn.vC_, kInt, kAccurate);
2014
2015 EmitGuard_ArrayException(dex_pc, array_addr, index_value);
2016
2017 llvm::Type* elem_type = irb_.getJType(elem_jty, kArray);
2018
2019 llvm::Value* array_elem_addr =
2020 EmitArrayGEP(array_addr, index_value, elem_type);
2021
2022 llvm::Value* array_elem_value = irb_.CreateLoad(array_elem_addr);
2023
2024 EmitStoreDalvikReg(dec_insn.vA_, elem_jty, kArray, array_elem_value);
2025
Logan Chien70f94b42011-12-27 17:49:11 +08002026 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2027}
2028
2029
2030void MethodCompiler::EmitInsn_APut(uint32_t dex_pc,
2031 Instruction const* insn,
2032 JType elem_jty) {
Logan Chien8dabb432012-01-02 23:29:32 +08002033
2034 Instruction::DecodedInstruction dec_insn(insn);
2035
2036 llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
2037 llvm::Value* index_value = EmitLoadDalvikReg(dec_insn.vC_, kInt, kAccurate);
2038
2039 EmitGuard_ArrayException(dex_pc, array_addr, index_value);
2040
2041 llvm::Type* elem_type = irb_.getJType(elem_jty, kArray);
2042
2043 llvm::Value* array_elem_addr =
2044 EmitArrayGEP(array_addr, index_value, elem_type);
2045
2046 llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, elem_jty, kArray);
2047
2048 irb_.CreateStore(new_value, array_elem_addr);
2049
Logan Chien70f94b42011-12-27 17:49:11 +08002050 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2051}
2052
2053
Logan Chien48f1d2a2012-01-02 22:49:53 +08002054void MethodCompiler::PrintUnresolvedFieldWarning(int32_t field_idx) {
2055 DexFile const& dex_file = method_helper_.GetDexFile();
2056 DexFile::FieldId const& field_id = dex_file.GetFieldId(field_idx);
2057
2058 LOG(WARNING) << "unable to resolve static field " << field_idx << " ("
2059 << dex_file.GetFieldName(field_id) << ") in "
2060 << dex_file.GetFieldDeclaringClassDescriptor(field_id);
2061}
2062
2063
Logan Chien70f94b42011-12-27 17:49:11 +08002064void MethodCompiler::EmitInsn_IGet(uint32_t dex_pc,
2065 Instruction const* insn,
2066 JType field_jty) {
Logan Chien48f1d2a2012-01-02 22:49:53 +08002067
2068 Instruction::DecodedInstruction dec_insn(insn);
2069
2070 uint32_t reg_idx = dec_insn.vB_;
2071 uint32_t field_idx = dec_insn.vC_;
2072
2073 Field* field = dex_cache_->GetResolvedField(field_idx);
2074
2075 llvm::Value* object_addr = EmitLoadDalvikReg(reg_idx, kObject, kAccurate);
2076
2077 EmitGuard_NullPointerException(dex_pc, object_addr);
2078
2079 llvm::Value* field_value;
2080
2081 if (field == NULL) {
2082 PrintUnresolvedFieldWarning(field_idx);
2083
2084 llvm::Function* runtime_func;
2085
2086 if (field_jty == kObject) {
2087 runtime_func = irb_.GetRuntime(SetObjectInstance);
2088 } else if (field_jty == kLong || field_jty == kDouble) {
2089 runtime_func = irb_.GetRuntime(Set64Instance);
2090 } else {
2091 runtime_func = irb_.GetRuntime(Set32Instance);
2092 }
2093
2094 llvm::ConstantInt* field_idx_value = irb_.getInt32(field_idx);
2095
2096 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2097
2098 field_value = irb_.CreateCall2(runtime_func, field_idx_value,
2099 method_object_addr);
2100
2101 EmitGuard_ExceptionLandingPad(dex_pc);
2102
2103 } else {
2104 llvm::PointerType* field_type =
2105 irb_.getJType(field_jty, kField)->getPointerTo();
2106
2107 llvm::ConstantInt* field_offset =
2108 irb_.getPtrEquivInt(field->GetOffset().Int32Value());
2109
2110 llvm::Value* field_addr =
2111 irb_.CreatePtrDisp(object_addr, field_offset, field_type);
2112
2113 field_value = irb_.CreateLoad(field_addr);
2114 }
2115
2116 EmitStoreDalvikReg(dec_insn.vA_, field_jty, kField, field_value);
2117
Logan Chien70f94b42011-12-27 17:49:11 +08002118 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2119}
2120
2121
2122void MethodCompiler::EmitInsn_IPut(uint32_t dex_pc,
2123 Instruction const* insn,
2124 JType field_jty) {
Logan Chiendd6aa872012-01-03 16:06:32 +08002125
2126 Instruction::DecodedInstruction dec_insn(insn);
2127
2128 uint32_t reg_idx = dec_insn.vB_;
2129 uint32_t field_idx = dec_insn.vC_;
2130
2131 Field* field = dex_cache_->GetResolvedField(field_idx);
2132
2133 llvm::Value* object_addr = EmitLoadDalvikReg(reg_idx, kObject, kAccurate);
2134
2135 EmitGuard_NullPointerException(dex_pc, object_addr);
2136
2137 llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, field_jty, kField);
2138
2139 if (field == NULL) {
2140 PrintUnresolvedFieldWarning(field_idx);
2141
2142 llvm::Function* runtime_func;
2143
2144 if (field_jty == kObject) {
2145 runtime_func = irb_.GetRuntime(SetObjectInstance);
2146 } else if (field_jty == kLong || field_jty == kDouble) {
2147 runtime_func = irb_.GetRuntime(Set64Instance);
2148 } else {
2149 runtime_func = irb_.GetRuntime(Set32Instance);
2150 }
2151
2152 llvm::Value* field_idx_value = irb_.getInt32(field_idx);
2153
2154 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2155
2156 irb_.CreateCall3(runtime_func, field_idx_value,
2157 method_object_addr, new_value);
2158
2159 EmitGuard_ExceptionLandingPad(dex_pc);
2160
2161 } else {
2162 llvm::PointerType* field_type =
2163 irb_.getJType(field_jty, kField)->getPointerTo();
2164
2165 llvm::Value* field_offset =
2166 irb_.getPtrEquivInt(field->GetOffset().Int32Value());
2167
2168 llvm::Value* field_addr =
2169 irb_.CreatePtrDisp(object_addr, field_offset, field_type);
2170
2171 irb_.CreateStore(new_value, field_addr);
2172 }
2173
Logan Chien70f94b42011-12-27 17:49:11 +08002174 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2175}
2176
2177
2178void MethodCompiler::EmitInsn_SGet(uint32_t dex_pc,
2179 Instruction const* insn,
2180 JType field_jty) {
2181 // UNIMPLEMENTED(WARNING);
2182 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2183}
2184
2185
2186void MethodCompiler::EmitInsn_SPut(uint32_t dex_pc,
2187 Instruction const* insn,
2188 JType field_jty) {
2189 // UNIMPLEMENTED(WARNING);
2190 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2191}
2192
2193
2194void MethodCompiler::EmitInsn_InvokeVirtual(uint32_t dex_pc,
2195 Instruction const* insn,
2196 bool is_range) {
2197 // UNIMPLEMENTED(WARNING);
2198 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2199}
2200
2201
2202void MethodCompiler::EmitInsn_InvokeSuper(uint32_t dex_pc,
2203 Instruction const* insn,
2204 bool is_range) {
2205 // UNIMPLEMENTED(WARNING);
2206 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2207}
2208
2209
2210void MethodCompiler::EmitInsn_InvokeDirect(uint32_t dex_pc,
2211 Instruction const* insn,
2212 bool is_range) {
2213 // UNIMPLEMENTED(WARNING);
2214 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2215}
2216
2217
2218void MethodCompiler::EmitInsn_InvokeStatic(uint32_t dex_pc,
2219 Instruction const* insn,
2220 bool is_range) {
2221 // UNIMPLEMENTED(WARNING);
2222 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2223}
2224
2225
2226void MethodCompiler::EmitInsn_InvokeInterface(uint32_t dex_pc,
2227 Instruction const* insn,
2228 bool is_range) {
2229 // UNIMPLEMENTED(WARNING);
2230 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2231}
2232
2233
2234void MethodCompiler::EmitInsn_Neg(uint32_t dex_pc,
2235 Instruction const* insn,
2236 JType op_jty) {
Logan Chien1b5685f2011-12-27 18:01:14 +08002237
2238 Instruction::DecodedInstruction dec_insn(insn);
2239
2240 DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
2241
2242 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
2243 llvm::Value* result_value = irb_.CreateNeg(src_value);
2244 EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
2245
Logan Chien70f94b42011-12-27 17:49:11 +08002246 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2247}
2248
2249
2250void MethodCompiler::EmitInsn_Not(uint32_t dex_pc,
2251 Instruction const* insn,
2252 JType op_jty) {
Logan Chiene53750d2011-12-27 18:02:27 +08002253
2254 Instruction::DecodedInstruction dec_insn(insn);
2255
2256 DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
2257
2258 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
2259 llvm::Value* result_value =
2260 irb_.CreateXor(src_value, static_cast<uint64_t>(-1));
2261
2262 EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
2263
Logan Chien70f94b42011-12-27 17:49:11 +08002264 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2265}
2266
2267
2268void MethodCompiler::EmitInsn_SExt(uint32_t dex_pc,
2269 Instruction const* insn) {
Logan Chien61752ad2011-12-27 18:03:51 +08002270
2271 Instruction::DecodedInstruction dec_insn(insn);
2272
2273 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
2274 llvm::Value* result_value = irb_.CreateSExt(src_value, irb_.getJLongTy());
2275 EmitStoreDalvikReg(dec_insn.vA_, kLong, kAccurate, result_value);
2276
Logan Chien70f94b42011-12-27 17:49:11 +08002277 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2278}
2279
2280
2281void MethodCompiler::EmitInsn_Trunc(uint32_t dex_pc,
2282 Instruction const* insn) {
Logan Chien17a57662011-12-27 18:05:14 +08002283
2284 Instruction::DecodedInstruction dec_insn(insn);
2285
2286 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kLong, kAccurate);
2287 llvm::Value* result_value = irb_.CreateTrunc(src_value, irb_.getJIntTy());
2288 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
2289
Logan Chien70f94b42011-12-27 17:49:11 +08002290 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2291}
2292
2293
2294void MethodCompiler::EmitInsn_TruncAndSExt(uint32_t dex_pc,
2295 Instruction const* insn,
2296 unsigned N) {
Logan Chienb6744c52011-12-27 18:06:26 +08002297
2298 Instruction::DecodedInstruction dec_insn(insn);
2299
2300 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
2301
2302 llvm::Value* trunc_value =
2303 irb_.CreateTrunc(src_value, llvm::Type::getIntNTy(*context_, N));
2304
2305 llvm::Value* result_value = irb_.CreateSExt(trunc_value, irb_.getJIntTy());
2306
2307 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
2308
Logan Chien70f94b42011-12-27 17:49:11 +08002309 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2310}
2311
2312
2313void MethodCompiler::EmitInsn_TruncAndZExt(uint32_t dex_pc,
2314 Instruction const* insn,
2315 unsigned N) {
Logan Chienb6744c52011-12-27 18:06:26 +08002316
2317 Instruction::DecodedInstruction dec_insn(insn);
2318
2319 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
2320
2321 llvm::Value* trunc_value =
2322 irb_.CreateTrunc(src_value, llvm::Type::getIntNTy(*context_, N));
2323
2324 llvm::Value* result_value = irb_.CreateZExt(trunc_value, irb_.getJIntTy());
2325
2326 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
2327
Logan Chien70f94b42011-12-27 17:49:11 +08002328 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2329}
2330
2331
2332void MethodCompiler::EmitInsn_FNeg(uint32_t dex_pc,
2333 Instruction const* insn,
2334 JType op_jty) {
Logan Chien7a48b092011-12-27 18:07:45 +08002335
2336 Instruction::DecodedInstruction dec_insn(insn);
2337
2338 DCHECK(op_jty == kFloat || op_jty == kDouble) << op_jty;
2339
2340 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
2341 llvm::Value* result_value = irb_.CreateFNeg(src_value);
2342 EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
2343
Logan Chien70f94b42011-12-27 17:49:11 +08002344 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2345}
2346
2347
2348void MethodCompiler::EmitInsn_IntToFP(uint32_t dex_pc,
2349 Instruction const* insn,
2350 JType src_jty,
2351 JType dest_jty) {
Logan Chien62dd4532011-12-27 18:09:00 +08002352
2353 Instruction::DecodedInstruction dec_insn(insn);
2354
2355 DCHECK(src_jty == kInt || src_jty == kLong) << src_jty;
2356 DCHECK(dest_jty == kFloat || dest_jty == kDouble) << dest_jty;
2357
2358 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, src_jty, kAccurate);
2359 llvm::Type* dest_type = irb_.getJType(dest_jty, kAccurate);
2360 llvm::Value* dest_value = irb_.CreateSIToFP(src_value, dest_type);
2361 EmitStoreDalvikReg(dec_insn.vA_, dest_jty, kAccurate, dest_value);
2362
Logan Chien70f94b42011-12-27 17:49:11 +08002363 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2364}
2365
2366
2367void MethodCompiler::EmitInsn_FPToInt(uint32_t dex_pc,
2368 Instruction const* insn,
2369 JType src_jty,
2370 JType dest_jty) {
Logan Chien12dc1752011-12-27 18:10:15 +08002371
2372 Instruction::DecodedInstruction dec_insn(insn);
2373
2374 DCHECK(src_jty == kFloat || src_jty == kDouble) << src_jty;
2375 DCHECK(dest_jty == kInt || dest_jty == kLong) << dest_jty;
2376
2377 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, src_jty, kAccurate);
2378 llvm::Type* dest_type = irb_.getJType(dest_jty, kAccurate);
2379 llvm::Value* dest_value = irb_.CreateFPToSI(src_value, dest_type);
2380 EmitStoreDalvikReg(dec_insn.vA_, dest_jty, kAccurate, dest_value);
2381
Logan Chien70f94b42011-12-27 17:49:11 +08002382 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2383}
2384
2385
2386void MethodCompiler::EmitInsn_FExt(uint32_t dex_pc,
2387 Instruction const* insn) {
Logan Chienc56ded92011-12-27 18:10:57 +08002388
2389 Instruction::DecodedInstruction dec_insn(insn);
2390
2391 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kFloat, kAccurate);
2392 llvm::Value* result_value = irb_.CreateFPExt(src_value, irb_.getJDoubleTy());
2393 EmitStoreDalvikReg(dec_insn.vA_, kDouble, kAccurate, result_value);
2394
Logan Chien70f94b42011-12-27 17:49:11 +08002395 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2396}
2397
2398
2399void MethodCompiler::EmitInsn_FTrunc(uint32_t dex_pc,
2400 Instruction const* insn) {
Logan Chien927744f2011-12-27 18:11:52 +08002401
2402 Instruction::DecodedInstruction dec_insn(insn);
2403
2404 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kDouble, kAccurate);
2405 llvm::Value* result_value = irb_.CreateFPTrunc(src_value, irb_.getJFloatTy());
2406 EmitStoreDalvikReg(dec_insn.vA_, kFloat, kAccurate, result_value);
2407
Logan Chien70f94b42011-12-27 17:49:11 +08002408 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2409}
2410
2411
2412void MethodCompiler::EmitInsn_IntArithm(uint32_t dex_pc,
2413 Instruction const* insn,
2414 IntArithmKind arithm,
2415 JType op_jty,
2416 bool is_2addr) {
Logan Chienc3f7d962011-12-27 18:13:18 +08002417
2418 Instruction::DecodedInstruction dec_insn(insn);
2419
2420 DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
2421
2422 llvm::Value* src1_value;
2423 llvm::Value* src2_value;
2424
2425 if (is_2addr) {
2426 src1_value = EmitLoadDalvikReg(dec_insn.vA_, op_jty, kAccurate);
2427 src2_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
2428 } else {
2429 src1_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
2430 src2_value = EmitLoadDalvikReg(dec_insn.vC_, op_jty, kAccurate);
2431 }
2432
2433 llvm::Value* result_value =
2434 EmitIntArithmResultComputation(dex_pc, src1_value, src2_value,
2435 arithm, op_jty);
2436
2437 EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
2438
Logan Chien70f94b42011-12-27 17:49:11 +08002439 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2440}
2441
2442
2443void MethodCompiler::EmitInsn_IntArithmImmediate(uint32_t dex_pc,
2444 Instruction const* insn,
2445 IntArithmKind arithm) {
Logan Chienc3f7d962011-12-27 18:13:18 +08002446
2447 Instruction::DecodedInstruction dec_insn(insn);
2448
2449 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
2450
2451 llvm::Value* imm_value = irb_.getInt32(dec_insn.vC_);
2452
2453 llvm::Value* result_value =
2454 EmitIntArithmResultComputation(dex_pc, src_value, imm_value, arithm, kInt);
2455
2456 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
2457
Logan Chien70f94b42011-12-27 17:49:11 +08002458 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2459}
2460
2461
Logan Chienc3f7d962011-12-27 18:13:18 +08002462llvm::Value*
2463MethodCompiler::EmitIntArithmResultComputation(uint32_t dex_pc,
2464 llvm::Value* lhs,
2465 llvm::Value* rhs,
2466 IntArithmKind arithm,
2467 JType op_jty) {
2468 DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
2469
2470 switch (arithm) {
2471 case kIntArithm_Add:
2472 return irb_.CreateAdd(lhs, rhs);
2473
2474 case kIntArithm_Sub:
2475 return irb_.CreateSub(lhs, rhs);
2476
2477 case kIntArithm_Mul:
2478 return irb_.CreateMul(lhs, rhs);
2479
2480 case kIntArithm_Div:
2481 EmitGuard_DivZeroException(dex_pc, rhs, op_jty);
2482 return irb_.CreateSDiv(lhs, rhs);
2483
2484 case kIntArithm_Rem:
2485 EmitGuard_DivZeroException(dex_pc, rhs, op_jty);
2486 return irb_.CreateSRem(lhs, rhs);
2487
2488 case kIntArithm_And:
2489 return irb_.CreateAnd(lhs, rhs);
2490
2491 case kIntArithm_Or:
2492 return irb_.CreateOr(lhs, rhs);
2493
2494 case kIntArithm_Xor:
2495 return irb_.CreateXor(lhs, rhs);
2496
2497 case kIntArithm_Shl:
2498 if (op_jty == kLong) {
2499 return irb_.CreateShl(lhs, irb_.CreateAnd(rhs, 0x3f));
2500 } else {
2501 return irb_.CreateShl(lhs, irb_.CreateAnd(rhs, 0x1f));
2502 }
2503
2504 case kIntArithm_Shr:
2505 if (op_jty == kLong) {
2506 return irb_.CreateAShr(lhs, irb_.CreateAnd(rhs, 0x3f));
2507 } else {
2508 return irb_.CreateAShr(lhs, irb_.CreateAnd(rhs, 0x1f));
2509 }
2510
2511 case kIntArithm_UShr:
2512 if (op_jty == kLong) {
2513 return irb_.CreateLShr(lhs, irb_.CreateAnd(rhs, 0x3f));
2514 } else {
2515 return irb_.CreateLShr(lhs, irb_.CreateAnd(rhs, 0x1f));
2516 }
2517
2518 default:
2519 LOG(FATAL) << "Unknown integer arithmetic kind: " << arithm;
2520 return NULL;
2521 }
2522}
2523
2524
Logan Chien70f94b42011-12-27 17:49:11 +08002525void MethodCompiler::EmitInsn_RSubImmediate(uint32_t dex_pc,
2526 Instruction const* insn) {
Logan Chien65c62d42011-12-27 18:14:18 +08002527
2528 Instruction::DecodedInstruction dec_insn(insn);
2529
2530 llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
2531 llvm::Value* imm_value = irb_.getInt32(dec_insn.vC_);
2532 llvm::Value* result_value = irb_.CreateSub(imm_value, src_value);
2533 EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
2534
Logan Chien70f94b42011-12-27 17:49:11 +08002535 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2536}
2537
2538
2539void MethodCompiler::EmitInsn_FPArithm(uint32_t dex_pc,
2540 Instruction const* insn,
2541 FPArithmKind arithm,
2542 JType op_jty,
2543 bool is_2addr) {
Logan Chien76e1c792011-12-27 18:15:01 +08002544
2545 Instruction::DecodedInstruction dec_insn(insn);
2546
2547 DCHECK(op_jty == kFloat || op_jty == kDouble) << op_jty;
2548
2549 llvm::Value* src1_value;
2550 llvm::Value* src2_value;
2551
2552 if (is_2addr) {
2553 src1_value = EmitLoadDalvikReg(dec_insn.vA_, op_jty, kAccurate);
2554 src2_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
2555 } else {
2556 src1_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
2557 src2_value = EmitLoadDalvikReg(dec_insn.vC_, op_jty, kAccurate);
2558 }
2559
2560 llvm::Value* result_value =
2561 EmitFPArithmResultComputation(dex_pc, src1_value, src2_value, arithm);
2562
2563 EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
2564
Logan Chien70f94b42011-12-27 17:49:11 +08002565 irb_.CreateBr(GetNextBasicBlock(dex_pc));
2566}
2567
2568
Logan Chien76e1c792011-12-27 18:15:01 +08002569llvm::Value*
2570MethodCompiler::EmitFPArithmResultComputation(uint32_t dex_pc,
2571 llvm::Value *lhs,
2572 llvm::Value *rhs,
2573 FPArithmKind arithm) {
2574 switch (arithm) {
2575 case kFPArithm_Add:
2576 return irb_.CreateFAdd(lhs, rhs);
2577
2578 case kFPArithm_Sub:
2579 return irb_.CreateFSub(lhs, rhs);
2580
2581 case kFPArithm_Mul:
2582 return irb_.CreateFMul(lhs, rhs);
2583
2584 case kFPArithm_Div:
2585 return irb_.CreateFDiv(lhs, rhs);
2586
2587 case kFPArithm_Rem:
2588 return irb_.CreateFRem(lhs, rhs);
2589
2590 default:
2591 LOG(FATAL) << "Unknown floating-point arithmetic kind: " << arithm;
2592 return NULL;
2593 }
2594}
2595
2596
Logan Chienc3f7d962011-12-27 18:13:18 +08002597void MethodCompiler::EmitGuard_DivZeroException(uint32_t dex_pc,
2598 llvm::Value* denominator,
2599 JType op_jty) {
2600 DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
2601
2602 llvm::Constant* zero = irb_.getJZero(op_jty);
2603
2604 llvm::Value* equal_zero = irb_.CreateICmpEQ(denominator, zero);
2605
2606 llvm::BasicBlock* block_exception = CreateBasicBlockWithDexPC(dex_pc, "div0");
2607
2608 llvm::BasicBlock* block_continue = CreateBasicBlockWithDexPC(dex_pc, "cont");
2609
2610 irb_.CreateCondBr(equal_zero, block_exception, block_continue);
2611
2612 irb_.SetInsertPoint(block_exception);
2613 irb_.CreateCall(irb_.GetRuntime(ThrowDivZeroException));
2614 EmitBranchExceptionLandingPad(dex_pc);
2615
2616 irb_.SetInsertPoint(block_continue);
2617}
2618
2619
Logan Chien61bb6142012-02-03 15:34:53 +08002620void MethodCompiler::EmitGuard_NullPointerException(uint32_t dex_pc,
2621 llvm::Value* object) {
2622 llvm::Value* equal_null = irb_.CreateICmpEQ(object, irb_.getJNull());
2623
2624 llvm::BasicBlock* block_exception =
2625 CreateBasicBlockWithDexPC(dex_pc, "nullp");
2626
2627 llvm::BasicBlock* block_continue =
2628 CreateBasicBlockWithDexPC(dex_pc, "cont");
2629
2630 irb_.CreateCondBr(equal_null, block_exception, block_continue);
2631
2632 irb_.SetInsertPoint(block_exception);
2633 irb_.CreateCall(irb_.GetRuntime(ThrowNullPointerException));
2634 EmitBranchExceptionLandingPad(dex_pc);
2635
2636 irb_.SetInsertPoint(block_continue);
2637}
2638
2639
Logan Chienbb4d12a2012-02-17 14:10:01 +08002640llvm::Value* MethodCompiler::EmitLoadDexCacheAddr(MemberOffset offset) {
2641 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2642
2643 llvm::Value* dex_cache_offset_value =
2644 irb_.getPtrEquivInt(offset.Int32Value());
2645
2646 llvm::Value* dex_cache_field_addr =
2647 irb_.CreatePtrDisp(method_object_addr, dex_cache_offset_value,
2648 irb_.getJObjectTy()->getPointerTo());
2649
2650 return irb_.CreateLoad(dex_cache_field_addr);
2651}
2652
2653
2654void MethodCompiler::
2655EmitLoadDexCacheCodeAndDirectMethodFieldAddr(llvm::Value*& code_field_addr,
2656 llvm::Value*& method_field_addr,
2657 uint32_t method_idx) {
2658 llvm::Value* cadms_dex_cache_addr =
2659 EmitLoadDexCacheAddr(Method::GetDexCacheCodeAndDirectMethodsOffset());
2660
2661 llvm::Value* code_index_value =
2662 irb_.getPtrEquivInt(CodeAndDirectMethods::CodeIndex(method_idx));
2663
2664 llvm::Value* method_index_value =
2665 irb_.getPtrEquivInt(CodeAndDirectMethods::MethodIndex(method_idx));
2666
2667 // Return the field address
2668 code_field_addr = EmitArrayGEP(cadms_dex_cache_addr, code_index_value,
2669 irb_.getJIntTy());
2670
2671 method_field_addr = EmitArrayGEP(cadms_dex_cache_addr, method_index_value,
2672 irb_.getJIntTy());
2673}
2674
2675
2676llvm::Value* MethodCompiler::
2677EmitLoadDexCacheStaticStorageFieldAddr(uint32_t type_idx) {
2678 llvm::Value* static_storage_dex_cache_addr =
2679 EmitLoadDexCacheAddr(Method::DexCacheInitializedStaticStorageOffset());
2680
2681 llvm::Value* type_idx_value = irb_.getPtrEquivInt(type_idx);
2682
2683 return EmitArrayGEP(static_storage_dex_cache_addr, type_idx_value,
2684 irb_.getJObjectTy());
2685}
2686
2687
2688llvm::Value* MethodCompiler::
2689EmitLoadDexCacheResolvedTypeFieldAddr(uint32_t type_idx) {
2690 llvm::Value* resolved_type_dex_cache_addr =
2691 EmitLoadDexCacheAddr(Method::DexCacheResolvedTypesOffset());
2692
2693 llvm::Value* type_idx_value = irb_.getPtrEquivInt(type_idx);
2694
2695 return EmitArrayGEP(resolved_type_dex_cache_addr, type_idx_value,
2696 irb_.getJObjectTy());
2697}
2698
2699
2700llvm::Value* MethodCompiler::
2701EmitLoadDexCacheStringFieldAddr(uint32_t string_idx) {
2702 llvm::Value* string_dex_cache_addr =
2703 EmitLoadDexCacheAddr(Method::DexCacheStringsOffset());
2704
2705 llvm::Value* string_idx_value = irb_.getPtrEquivInt(string_idx);
2706
2707 return EmitArrayGEP(string_dex_cache_addr, string_idx_value,
2708 irb_.getJObjectTy());
2709}
2710
2711
Logan Chien83426162011-12-09 09:29:50 +08002712CompiledMethod *MethodCompiler::Compile() {
Logan Chien0b827102011-12-20 19:46:14 +08002713 // Code generation
2714 CreateFunction();
2715
2716 EmitPrologue();
2717 EmitInstructions();
Logan Chienc670a8d2011-12-20 21:25:56 +08002718 EmitPrologueLastBranch();
Logan Chien0b827102011-12-20 19:46:14 +08002719
Logan Chiend6c239a2011-12-23 15:11:45 +08002720 // Verify the generated bitcode
2721 llvm::verifyFunction(*func_, llvm::PrintMessageAction);
2722
Logan Chien0b827102011-12-20 19:46:14 +08002723 // Delete the inferred register category map (won't be used anymore)
2724 method_->ResetInferredRegCategoryMap();
2725
2726 return new CompiledMethod(insn_set_, func_);
2727}
2728
2729
2730llvm::Value* MethodCompiler::EmitLoadMethodObjectAddr() {
2731 return func_->arg_begin();
Shih-wei Liaod1fec812012-02-13 09:51:10 -08002732}
Logan Chien83426162011-12-09 09:29:50 +08002733
2734
Logan Chien5bcc04e2012-01-30 14:15:12 +08002735void MethodCompiler::EmitBranchExceptionLandingPad(uint32_t dex_pc) {
2736 if (llvm::BasicBlock* lpad = GetLandingPadBasicBlock(dex_pc)) {
2737 irb_.CreateBr(lpad);
2738 } else {
2739 irb_.CreateBr(GetUnwindBasicBlock());
2740 }
2741}
2742
2743
2744void MethodCompiler::EmitGuard_ExceptionLandingPad(uint32_t dex_pc) {
2745 llvm::Value* exception_pending =
2746 irb_.CreateCall(irb_.GetRuntime(IsExceptionPending));
2747
2748 llvm::BasicBlock* block_cont = CreateBasicBlockWithDexPC(dex_pc, "cont");
2749
2750 if (llvm::BasicBlock* lpad = GetLandingPadBasicBlock(dex_pc)) {
2751 irb_.CreateCondBr(exception_pending, lpad, block_cont);
2752 } else {
2753 irb_.CreateCondBr(exception_pending, GetUnwindBasicBlock(), block_cont);
2754 }
2755
2756 irb_.SetInsertPoint(block_cont);
2757}
2758
2759
Logan Chien924072f2012-01-30 15:07:24 +08002760void MethodCompiler::EmitGuard_GarbageCollectionSuspend(uint32_t dex_pc) {
2761 llvm::Value* runtime_func = irb_.GetRuntime(TestSuspend);
2762 irb_.CreateCall(runtime_func);
2763
2764 EmitGuard_ExceptionLandingPad(dex_pc);
2765}
2766
2767
Logan Chiend6c239a2011-12-23 15:11:45 +08002768llvm::BasicBlock* MethodCompiler::
2769CreateBasicBlockWithDexPC(uint32_t dex_pc, char const* postfix) {
2770 std::string name;
2771
2772 if (postfix) {
2773 StringAppendF(&name, "B%u.%s", dex_pc, postfix);
2774 } else {
2775 StringAppendF(&name, "B%u", dex_pc);
2776 }
2777
2778 return llvm::BasicBlock::Create(*context_, name, func_);
2779}
2780
2781
2782llvm::BasicBlock* MethodCompiler::GetBasicBlock(uint32_t dex_pc) {
2783 DCHECK(dex_pc < code_item_->insns_size_in_code_units_);
2784
2785 llvm::BasicBlock* basic_block = basic_blocks_[dex_pc];
2786
2787 if (!basic_block) {
2788 basic_block = CreateBasicBlockWithDexPC(dex_pc);
2789 basic_blocks_[dex_pc] = basic_block;
2790 }
2791
2792 return basic_block;
2793}
2794
2795
2796llvm::BasicBlock*
2797MethodCompiler::GetNextBasicBlock(uint32_t dex_pc) {
2798 Instruction const* insn = Instruction::At(code_item_->insns_ + dex_pc);
2799 return GetBasicBlock(dex_pc + insn->SizeInCodeUnits());
2800}
2801
2802
Logan Chien5bcc04e2012-01-30 14:15:12 +08002803int32_t MethodCompiler::GetTryItemOffset(uint32_t dex_pc) {
2804 // TODO: Since we are emitting the dex instructions in ascending order
2805 // w.r.t. address, we can cache the lastest try item offset so that we
2806 // don't have to do binary search for every query.
2807
2808 int32_t min = 0;
2809 int32_t max = code_item_->tries_size_ - 1;
2810
2811 while (min <= max) {
2812 int32_t mid = min + (max - min) / 2;
2813
2814 DexFile::TryItem const* ti = DexFile::GetTryItems(*code_item_, mid);
2815 uint32_t start = ti->start_addr_;
2816 uint32_t end = start + ti->insn_count_;
2817
2818 if (dex_pc < start) {
2819 max = mid - 1;
2820 } else if (dex_pc >= end) {
2821 min = mid + 1;
2822 } else {
2823 return mid; // found
2824 }
2825 }
2826
2827 return -1; // not found
2828}
2829
2830
2831llvm::BasicBlock* MethodCompiler::GetLandingPadBasicBlock(uint32_t dex_pc) {
2832 // Find the try item for this address in this method
2833 int32_t ti_offset = GetTryItemOffset(dex_pc);
2834
2835 if (ti_offset == -1) {
2836 return NULL; // No landing pad is available for this address.
2837 }
2838
2839 // Check for the existing landing pad basic block
2840 DCHECK_GT(basic_block_landing_pads_.size(), static_cast<size_t>(ti_offset));
2841 llvm::BasicBlock* block_lpad = basic_block_landing_pads_[ti_offset];
2842
2843 if (block_lpad) {
2844 // We have generated landing pad for this try item already. Return the
2845 // same basic block.
2846 return block_lpad;
2847 }
2848
2849 // Get try item from code item
2850 DexFile::TryItem const* ti = DexFile::GetTryItems(*code_item_, ti_offset);
2851
2852 // Create landing pad basic block
2853 block_lpad = llvm::BasicBlock::Create(*context_,
2854 StringPrintf("lpad%d", ti_offset),
2855 func_);
2856
2857 // Change IRBuilder insert point
2858 llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
2859 irb_.SetInsertPoint(block_lpad);
2860
2861 // Find catch block with matching type
2862 llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
2863
2864 // TODO: Maybe passing try item offset will be a better idea? For now,
2865 // we are passing dex_pc, so that we can use existing runtime support
2866 // function directly. However, in the runtime supporting function we
2867 // have to search for try item with binary search which can be
2868 // eliminated.
2869 llvm::Value* dex_pc_value = irb_.getInt32(ti->start_addr_);
2870
2871 llvm::Value* catch_handler_index_value =
2872 irb_.CreateCall2(irb_.GetRuntime(FindCatchBlock),
2873 method_object_addr, dex_pc_value);
2874
2875 // Switch instruction (Go to unwind basic block by default)
2876 llvm::SwitchInst* sw =
2877 irb_.CreateSwitch(catch_handler_index_value, GetUnwindBasicBlock());
2878
2879 // Cases with matched catch block
2880 CatchHandlerIterator iter(*code_item_, ti->start_addr_);
2881
2882 for (uint32_t c = 0; iter.HasNext(); iter.Next(), ++c) {
2883 sw->addCase(irb_.getInt32(c), GetBasicBlock(iter.GetHandlerAddress()));
2884 }
2885
2886 // Restore the orignal insert point for IRBuilder
2887 irb_.restoreIP(irb_ip_original);
2888
2889 // Cache this landing pad
2890 DCHECK_GT(basic_block_landing_pads_.size(), static_cast<size_t>(ti_offset));
2891 basic_block_landing_pads_[ti_offset] = block_lpad;
2892
2893 return block_lpad;
2894}
2895
2896
2897llvm::BasicBlock* MethodCompiler::GetUnwindBasicBlock() {
2898 // Check the existing unwinding baisc block block
2899 if (basic_block_unwind_ != NULL) {
2900 return basic_block_unwind_;
2901 }
2902
2903 // Create new basic block for unwinding
2904 basic_block_unwind_ =
2905 llvm::BasicBlock::Create(*context_, "exception_unwind", func_);
2906
2907 // Change IRBuilder insert point
2908 llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
2909 irb_.SetInsertPoint(basic_block_unwind_);
2910
2911 // Emit the code to return default value (zero) for the given return type.
2912 char ret_shorty = method_helper_.GetShorty()[0];
2913 if (ret_shorty == 'V') {
2914 irb_.CreateRetVoid();
2915 } else {
2916 irb_.CreateRet(irb_.getJZero(ret_shorty));
2917 }
2918
2919 // Restore the orignal insert point for IRBuilder
2920 irb_.restoreIP(irb_ip_original);
2921
2922 return basic_block_unwind_;
2923}
2924
2925
Logan Chienc670a8d2011-12-20 21:25:56 +08002926llvm::Value* MethodCompiler::AllocDalvikLocalVarReg(RegCategory cat,
2927 uint32_t reg_idx) {
2928
2929 // Save current IR builder insert point
2930 llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
2931
2932 // Alloca
2933 llvm::Value* reg_addr = NULL;
2934
2935 switch (cat) {
2936 case kRegCat1nr:
2937 irb_.SetInsertPoint(basic_block_reg_alloca_);
2938 reg_addr = irb_.CreateAlloca(irb_.getJIntTy(), 0,
2939 StringPrintf("r%u", reg_idx));
2940
2941 irb_.SetInsertPoint(basic_block_reg_zero_init_);
2942 irb_.CreateStore(irb_.getJInt(0), reg_addr);
2943 break;
2944
2945 case kRegCat2:
2946 irb_.SetInsertPoint(basic_block_reg_alloca_);
2947 reg_addr = irb_.CreateAlloca(irb_.getJLongTy(), 0,
2948 StringPrintf("w%u", reg_idx));
2949
2950 irb_.SetInsertPoint(basic_block_reg_zero_init_);
2951 irb_.CreateStore(irb_.getJLong(0), reg_addr);
2952 break;
2953
2954 case kRegObject:
2955 irb_.SetInsertPoint(basic_block_reg_alloca_);
2956 reg_addr = irb_.CreateAlloca(irb_.getJObjectTy(), 0,
2957 StringPrintf("p%u", reg_idx));
2958
2959 irb_.SetInsertPoint(basic_block_reg_zero_init_);
2960 irb_.CreateStore(irb_.getJNull(), reg_addr);
2961 break;
2962
2963 default:
2964 LOG(FATAL) << "Unknown register category for allocation: " << cat;
2965 }
2966
2967 // Restore IRBuilder insert point
2968 irb_.restoreIP(irb_ip_original);
2969
2970 DCHECK_NE(reg_addr, static_cast<llvm::Value*>(NULL));
2971 return reg_addr;
2972}
2973
2974
2975llvm::Value* MethodCompiler::AllocDalvikRetValReg(RegCategory cat) {
2976 // Save current IR builder insert point
2977 llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
2978
2979 // Alloca
2980 llvm::Value* reg_addr = NULL;
2981
2982 switch (cat) {
2983 case kRegCat1nr:
2984 irb_.SetInsertPoint(basic_block_reg_alloca_);
2985 reg_addr = irb_.CreateAlloca(irb_.getJIntTy(), 0, "r_res");
2986 break;
2987
2988 case kRegCat2:
2989 irb_.SetInsertPoint(basic_block_reg_alloca_);
2990 reg_addr = irb_.CreateAlloca(irb_.getJLongTy(), 0, "w_res");
2991 break;
2992
2993 case kRegObject:
2994 irb_.SetInsertPoint(basic_block_reg_alloca_);
2995 reg_addr = irb_.CreateAlloca(irb_.getJObjectTy(), 0, "p_res");
2996 break;
2997
2998 default:
2999 LOG(FATAL) << "Unknown register category for allocation: " << cat;
3000 }
3001
3002 // Restore IRBuilder insert point
3003 irb_.restoreIP(irb_ip_original);
3004
3005 DCHECK_NE(reg_addr, static_cast<llvm::Value*>(NULL));
3006 return reg_addr;
3007}
3008
3009
Logan Chien83426162011-12-09 09:29:50 +08003010} // namespace compiler_llvm
3011} // namespace art