/
ciType.hpp
141 lines (108 loc) · 4.31 KB
/
ciType.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/*
* Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#ifndef SHARE_CI_CITYPE_HPP
#define SHARE_CI_CITYPE_HPP
#include "ci/ciMetadata.hpp"
// ciType
//
// This class represents a Java reference, inline type or primitive type.
class ciType : public ciMetadata {
CI_PACKAGE_ACCESS
friend class ciKlass;
friend class ciReturnAddress;
friend class ciWrapper;
private:
BasicType _basic_type;
ciType(BasicType t); // for primitive and unloaded types
ciType(Klass* k); // for subclasses (reference types)
const char* type_string() { return "ciType"; }
void print_impl(outputStream* st);
// Distinguished instances of primitive ciTypes..
static ciType* _basic_types[T_CONFLICT+1];
public:
BasicType basic_type() const { return _basic_type; }
// Returns true iff the types are identical, or if both are klasses
// and the is_subtype_of relation holds between the klasses.
bool is_subtype_of(ciType* type);
// Get the instance of java.lang.Class corresponding to this type.
// There are mirrors for instance, array, and primitive types (incl. void).
virtual ciInstance* java_mirror();
// Returns true if this is not a klass or array (i.e., not a reference type).
bool is_primitive_type() const { return !is_reference_type(basic_type()); }
int size() const { return type2size[basic_type()]; }
bool is_void() const { return basic_type() == T_VOID; }
bool is_one_word() const { return size() == 1; }
bool is_two_word() const { return size() == 2; }
// What kind of ciObject is this?
bool is_type() const { return true; }
bool is_classless() const { return is_primitive_type(); }
virtual ciType* unwrap() { return this; }
virtual bool is_null_free() const { return false; }
const char* name();
virtual void print_name_on(outputStream* st);
void print_name() {
print_name_on(tty);
}
static ciType* make(BasicType t);
};
// ciReturnAddress
//
// This class represents the type of a specific return address in the
// bytecodes.
class ciReturnAddress : public ciType {
CI_PACKAGE_ACCESS
private:
// The bci of this return address.
int _bci;
ciReturnAddress(int bci);
const char* type_string() { return "ciReturnAddress"; }
void print_impl(outputStream* st);
public:
bool is_return_address() const { return true; }
int bci() { return _bci; }
static ciReturnAddress* make(int bci);
};
// ciWrapper
//
// This class wraps another type to carry additional information.
// Currently it is only used to mark inline klasses as null-free.
class ciWrapper : public ciType {
CI_PACKAGE_ACCESS
private:
ciType* _type;
ciWrapper(ciType* type) : ciType(type->basic_type()) {
assert(type->is_inlinetype()
// An unloaded inline type is an instance_klass (see ciEnv::get_klass_by_name_impl())
|| (type->is_instance_klass() && !type->is_loaded()),
"should only be used for inline types");
_type = type;
}
const char* type_string() { return "ciWrapper"; }
void print_impl(outputStream* st) { _type->print_impl(st); }
public:
bool is_wrapper() const { return true; }
ciType* unwrap() { return _type; }
bool is_null_free() const { return true; }
};
#endif // SHARE_CI_CITYPE_HPP