ciKlass.cpp revision 3602:da91efe96a93 
1/*
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.
4 *
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
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25#include "precompiled.hpp"
26#include "ci/ciKlass.hpp"
27#include "ci/ciSymbol.hpp"
28#include "ci/ciUtilities.hpp"
29#include "oops/oop.inline.hpp"
30
31// ciKlass
32//
33// This class represents a Klass* in the HotSpot virtual
34// machine.
35
36// ------------------------------------------------------------------
37// ciKlass::ciKlass
38ciKlass::ciKlass(KlassHandle h_k) : ciType(h_k) {
39  assert(get_Klass()->is_klass(), "wrong type");
40  Klass* k = get_Klass();
41  _layout_helper = k->layout_helper();
42  Symbol* klass_name = k->name();
43  assert(klass_name != NULL, "wrong ciKlass constructor");
44  _name = CURRENT_ENV->get_symbol(klass_name);
45}
46
47// ------------------------------------------------------------------
48// ciKlass::ciKlass
49//
50// Nameless klass variant.
51ciKlass::ciKlass(KlassHandle h_k, ciSymbol* name) : ciType(h_k) {
52  assert(get_Klass()->is_klass(), "wrong type");
53  _name = name;
54  _layout_helper = Klass::_lh_neutral_value;
55}
56
57// ------------------------------------------------------------------
58// ciKlass::ciKlass
59//
60// Unloaded klass variant.
61ciKlass::ciKlass(ciSymbol* name, BasicType bt) : ciType(bt) {
62  _name = name;
63  _layout_helper = Klass::_lh_neutral_value;
64}
65
66// ------------------------------------------------------------------
67// ciKlass::is_subtype_of
68bool ciKlass::is_subtype_of(ciKlass* that) {
69  assert(is_loaded() && that->is_loaded(), "must be loaded");
70  // Check to see if the klasses are identical.
71  if (this == that) {
72    return true;
73  }
74
75  VM_ENTRY_MARK;
76  Klass* this_klass = get_Klass();
77  Klass* that_klass = that->get_Klass();
78  bool result = this_klass->is_subtype_of(that_klass);
79
80  return result;
81}
82
83// ------------------------------------------------------------------
84// ciKlass::is_subclass_of
85bool ciKlass::is_subclass_of(ciKlass* that) {
86  assert(is_loaded() && that->is_loaded(), "must be loaded");
87  // Check to see if the klasses are identical.
88
89  VM_ENTRY_MARK;
90  Klass* this_klass = get_Klass();
91  Klass* that_klass = that->get_Klass();
92  bool result = this_klass->is_subclass_of(that_klass);
93
94  return result;
95}
96
97// ------------------------------------------------------------------
98// ciKlass::super_depth
99juint ciKlass::super_depth() {
100  assert(is_loaded(), "must be loaded");
101
102  VM_ENTRY_MARK;
103  Klass* this_klass = get_Klass();
104  return this_klass->super_depth();
105}
106
107// ------------------------------------------------------------------
108// ciKlass::super_check_offset
109juint ciKlass::super_check_offset() {
110  assert(is_loaded(), "must be loaded");
111
112  VM_ENTRY_MARK;
113  Klass* this_klass = get_Klass();
114  return this_klass->super_check_offset();
115}
116
117// ------------------------------------------------------------------
118// ciKlass::super_of_depth
119ciKlass* ciKlass::super_of_depth(juint i) {
120  assert(is_loaded(), "must be loaded");
121
122  VM_ENTRY_MARK;
123  Klass* this_klass = get_Klass();
124  Klass* super = this_klass->primary_super_of_depth(i);
125  return (super != NULL) ? CURRENT_THREAD_ENV->get_klass(super) : NULL;
126}
127
128// ------------------------------------------------------------------
129// ciKlass::can_be_primary_super
130bool ciKlass::can_be_primary_super() {
131  assert(is_loaded(), "must be loaded");
132
133  VM_ENTRY_MARK;
134  Klass* this_klass = get_Klass();
135  return this_klass->can_be_primary_super();
136}
137
138// ------------------------------------------------------------------
139// ciKlass::least_common_ancestor
140//
141// Get the shared parent of two klasses.
142//
143// Implementation note: this method currently goes "over the wall"
144// and does all of the work on the VM side.  It could be rewritten
145// to use the super() method and do all of the work (aside from the
146// lazy computation of super()) in native mode.  This may be
147// worthwhile if the compiler is repeatedly requesting the same lca
148// computation or possibly if most of the superklasses have already
149// been created as ciObjects anyway.  Something to think about...
150ciKlass*
151ciKlass::least_common_ancestor(ciKlass* that) {
152  assert(is_loaded() && that->is_loaded(), "must be loaded");
153  // Check to see if the klasses are identical.
154  if (this == that) {
155    return this;
156  }
157
158  VM_ENTRY_MARK;
159  Klass* this_klass = get_Klass();
160  Klass* that_klass = that->get_Klass();
161  Klass* lca        = this_klass->LCA(that_klass);
162
163  // Many times the LCA will be either this_klass or that_klass.
164  // Treat these as special cases.
165  if (lca == that_klass) {
166    return that;
167  }
168  if (this_klass == lca) {
169    return this;
170  }
171
172  // Create the ciInstanceKlass for the lca.
173  ciKlass* result =
174    CURRENT_THREAD_ENV->get_klass(lca);
175
176  return result;
177}
178
179// ------------------------------------------------------------------
180// ciKlass::find_klass
181//
182// Find a klass using this klass's class loader.
183ciKlass* ciKlass::find_klass(ciSymbol* klass_name) {
184  assert(is_loaded(), "cannot find_klass through an unloaded klass");
185  return CURRENT_ENV->get_klass_by_name(this,
186                                        klass_name, false);
187}
188
189// ------------------------------------------------------------------
190// ciKlass::java_mirror
191//
192// Get the instance of java.lang.Class corresponding to this klass.
193// If it is an unloaded instance or array klass, return an unloaded
194// mirror object of type Class.
195ciInstance* ciKlass::java_mirror() {
196  GUARDED_VM_ENTRY(
197    if (!is_loaded())
198      return ciEnv::current()->get_unloaded_klass_mirror(this);
199    oop java_mirror = get_Klass()->java_mirror();
200    return CURRENT_ENV->get_instance(java_mirror);
201  )
202}
203
204// ------------------------------------------------------------------
205// ciKlass::modifier_flags
206jint ciKlass::modifier_flags() {
207  assert(is_loaded(), "not loaded");
208  GUARDED_VM_ENTRY(
209    return get_Klass()->modifier_flags();
210  )
211}
212
213// ------------------------------------------------------------------
214// ciKlass::access_flags
215jint ciKlass::access_flags() {
216  assert(is_loaded(), "not loaded");
217  GUARDED_VM_ENTRY(
218    return get_Klass()->access_flags().as_int();
219  )
220}
221
222// ------------------------------------------------------------------
223// ciKlass::print_impl
224//
225// Implementation of the print method
226void ciKlass::print_impl(outputStream* st) {
227  st->print(" name=");
228  print_name_on(st);
229}
230
231// ------------------------------------------------------------------
232// ciKlass::print_name
233//
234// Print the name of this klass
235void ciKlass::print_name_on(outputStream* st) {
236  name()->print_symbol_on(st);
237}
238