Mercurial > hg > truffle

comparison src/cpu/sparc/vm/c1_Runtime1_sparc.cpp @ 6725:da91efe96a93

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author coleenp
date Sat, 01 Sep 2012 13:25:18 -0400
parents 22cee0ee8927
children db9981fd3124
comparison
equal deleted inserted replaced
6724:36d1d483d5d6 6725:da91efe96a93
1 /* 1 /*
2 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. 2 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 * 4 *
5 * This code is free software; you can redistribute it and/or modify it 5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as 6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. 7 * published by the Free Software Foundation.
26 #include "c1/c1_Defs.hpp" 26 #include "c1/c1_Defs.hpp"
27 #include "c1/c1_MacroAssembler.hpp" 27 #include "c1/c1_MacroAssembler.hpp"
28 #include "c1/c1_Runtime1.hpp" 28 #include "c1/c1_Runtime1.hpp"
29 #include "interpreter/interpreter.hpp" 29 #include "interpreter/interpreter.hpp"
30 #include "nativeInst_sparc.hpp" 30 #include "nativeInst_sparc.hpp"
31 #include "oops/compiledICHolderOop.hpp" 31 #include "oops/compiledICHolder.hpp"
32 #include "oops/oop.inline.hpp" 32 #include "oops/oop.inline.hpp"
33 #include "prims/jvmtiExport.hpp" 33 #include "prims/jvmtiExport.hpp"
34 #include "register_sparc.hpp" 34 #include "register_sparc.hpp"
35 #include "runtime/sharedRuntime.hpp" 35 #include "runtime/sharedRuntime.hpp"
36 #include "runtime/signature.hpp" 36 #include "runtime/signature.hpp"
37 #include "runtime/vframeArray.hpp" 37 #include "runtime/vframeArray.hpp"
38 #include "vmreg_sparc.inline.hpp" 38 #include "vmreg_sparc.inline.hpp"
39 39
40 // Implementation of StubAssembler 40 // Implementation of StubAssembler
41 41
42 int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry_point, int number_of_arguments) { 42 int StubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry_point, int number_of_arguments) {
43 // for sparc changing the number of arguments doesn't change 43 // for sparc changing the number of arguments doesn't change
44 // anything about the frame size so we'll always lie and claim that 44 // anything about the frame size so we'll always lie and claim that
45 // we are only passing 1 argument. 45 // we are only passing 1 argument.
46 set_num_rt_args(1); 46 set_num_rt_args(1);
47 47
98 // be a little paranoid and clear the result 98 // be a little paranoid and clear the result
99 Address vm_result_addr(G2_thread, JavaThread::vm_result_offset()); 99 Address vm_result_addr(G2_thread, JavaThread::vm_result_offset());
100 st_ptr(G0, vm_result_addr); 100 st_ptr(G0, vm_result_addr);
101 } 101 }
102 102
103 if (oop_result2->is_valid()) { 103 // get second result if there is one and reset the value in the thread
104 get_vm_result_2(oop_result2); 104 if (metadata_result->is_valid()) {
105 get_vm_result_2 (metadata_result);
105 } else { 106 } else {
106 // be a little paranoid and clear the result 107 // be a little paranoid and clear the result
107 Address vm_result_addr_2(G2_thread, JavaThread::vm_result_2_offset()); 108 Address vm_result_addr_2(G2_thread, JavaThread::vm_result_2_offset());
108 st_ptr(G0, vm_result_addr_2); 109 st_ptr(G0, vm_result_addr_2);
109 } 110 }
110 111
111 return call_offset; 112 return call_offset;
112 } 113 }
113 114
114 115
115 int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1) { 116 int StubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1) {
116 // O0 is reserved for the thread 117 // O0 is reserved for the thread
117 mov(arg1, O1); 118 mov(arg1, O1);
118 return call_RT(oop_result1, oop_result2, entry, 1); 119 return call_RT(oop_result1, metadata_result, entry, 1);
119 } 120 }
120 121
121 122
122 int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1, Register arg2) { 123 int StubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1, Register arg2) {
123 // O0 is reserved for the thread 124 // O0 is reserved for the thread
124 mov(arg1, O1); 125 mov(arg1, O1);
125 mov(arg2, O2); assert(arg2 != O1, "smashed argument"); 126 mov(arg2, O2); assert(arg2 != O1, "smashed argument");
126 return call_RT(oop_result1, oop_result2, entry, 2); 127 return call_RT(oop_result1, metadata_result, entry, 2);
127 } 128 }
128 129
129 130
130 int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1, Register arg2, Register arg3) { 131 int StubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1, Register arg2, Register arg3) {
131 // O0 is reserved for the thread 132 // O0 is reserved for the thread
132 mov(arg1, O1); 133 mov(arg1, O1);
133 mov(arg2, O2); assert(arg2 != O1, "smashed argument"); 134 mov(arg2, O2); assert(arg2 != O1, "smashed argument");
134 mov(arg3, O3); assert(arg3 != O1 && arg3 != O2, "smashed argument"); 135 mov(arg3, O3); assert(arg3 != O1 && arg3 != O2, "smashed argument");
135 return call_RT(oop_result1, oop_result2, entry, 3); 136 return call_RT(oop_result1, metadata_result, entry, 3);
136 } 137 }
137 138
138 139
139 // Implementation of Runtime1 140 // Implementation of Runtime1
140 141
396 // to stomp the real return address. 397 // to stomp the real return address.
397 __ save_frame(0); 398 __ save_frame(0);
398 399
399 if (id == fast_new_instance_init_check_id) { 400 if (id == fast_new_instance_init_check_id) {
400 // make sure the klass is initialized 401 // make sure the klass is initialized
401 __ ldub(G5_klass, in_bytes(instanceKlass::init_state_offset()), G3_t1); 402 __ ldub(G5_klass, in_bytes(InstanceKlass::init_state_offset()), G3_t1);
402 __ cmp_and_br_short(G3_t1, instanceKlass::fully_initialized, Assembler::notEqual, Assembler::pn, slow_path); 403 __ cmp_and_br_short(G3_t1, InstanceKlass::fully_initialized, Assembler::notEqual, Assembler::pn, slow_path);
403 } 404 }
404 #ifdef ASSERT 405 #ifdef ASSERT
405 // assert object can be fast path allocated 406 // assert object can be fast path allocated
406 { 407 {
407 Label ok, not_ok; 408 Label ok, not_ok;
791 break; 792 break;
792 793
793 case load_klass_patching_id: 794 case load_klass_patching_id:
794 { __ set_info("load_klass_patching", dont_gc_arguments); 795 { __ set_info("load_klass_patching", dont_gc_arguments);
795 oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_klass_patching)); 796 oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_klass_patching));
797 }
798 break;
799
800 case load_mirror_patching_id:
801 { __ set_info("load_mirror_patching", dont_gc_arguments);
802 oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_mirror_patching));
796 } 803 }
797 break; 804 break;
798 805
799 case dtrace_object_alloc_id: 806 case dtrace_object_alloc_id:
800 { // O0: object 807 { // O0: object