1 /*
2 * Copyright (c) 1999, 2010, 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 "c1/c1_ValueType.hpp"
27 #include "ci/ciArray.hpp"
28 #include "ci/ciInstance.hpp"
29 #include "ci/ciNullObject.hpp"
30
31
32 // predefined types
33 VoidType* voidType = NULL;
34 IntType* intType = NULL;
35 LongType* longType = NULL;
36 FloatType* floatType = NULL;
37 DoubleType* doubleType = NULL;
38 ObjectType* objectType = NULL;
39 ArrayType* arrayType = NULL;
40 InstanceType* instanceType = NULL;
41 ClassType* classType = NULL;
42 AddressType* addressType = NULL;
43 IllegalType* illegalType = NULL;
44
45
46 // predefined constants
47 IntConstant* intZero = NULL;
48 IntConstant* intOne = NULL;
49 ObjectConstant* objectNull = NULL;
50
51
52 void ValueType::initialize(Arena* arena) {
53 // Note: Must initialize all types for each compilation
54 // as they are allocated within a ResourceMark!
55
56 // types
57 voidType = new (arena) VoidType();
58 intType = new (arena) IntType();
59 longType = new (arena) LongType();
60 floatType = new (arena) FloatType();
61 doubleType = new (arena) DoubleType();
62 objectType = new (arena) ObjectType();
63 arrayType = new (arena) ArrayType();
64 instanceType = new (arena) InstanceType();
65 classType = new (arena) ClassType();
66 addressType = new (arena) AddressType();
67 illegalType = new (arena) IllegalType();
68
69 intZero = new (arena) IntConstant(0);
70 intOne = new (arena) IntConstant(1);
71 objectNull = new (arena) ObjectConstant(ciNullObject::make());
72 };
73
74
75 ValueType* ValueType::meet(ValueType* y) const {
76 // incomplete & conservative solution for now - fix this!
77 assert(tag() == y->tag(), "types must match");
78 return base();
79 }
80
81
82 ValueType* ValueType::join(ValueType* y) const {
83 Unimplemented();
84 return NULL;
85 }
86
87
88
89 jobject ObjectType::encoding() const {
90 assert(is_constant(), "must be");
91 return constant_value()->constant_encoding();
92 }
93
94 bool ObjectType::is_loaded() const {
95 assert(is_constant(), "must be");
96 return constant_value()->is_loaded();
97 }
98
99 ciObject* ObjectConstant::constant_value() const { return _value; }
100 ciObject* ArrayConstant::constant_value() const { return _value; }
101 ciObject* InstanceConstant::constant_value() const { return _value; }
102 ciObject* ClassConstant::constant_value() const { return _value; }
103
104
105 ValueType* as_ValueType(BasicType type) {
106 switch (type) {
107 case T_VOID : return voidType;
108 case T_BYTE : // fall through
109 case T_CHAR : // fall through
110 case T_SHORT : // fall through
111 case T_BOOLEAN: // fall through
112 case T_INT : return intType;
113 case T_LONG : return longType;
114 case T_FLOAT : return floatType;
115 case T_DOUBLE : return doubleType;
116 case T_ARRAY : return arrayType;
117 case T_OBJECT : return objectType;
118 case T_ADDRESS: return addressType;
119 case T_ILLEGAL: return illegalType;
120 }
121 ShouldNotReachHere();
122 return illegalType;
123 }
124
125
126 ValueType* as_ValueType(ciConstant value) {
127 switch (value.basic_type()) {
128 case T_BYTE : // fall through
129 case T_CHAR : // fall through
130 case T_SHORT : // fall through
131 case T_BOOLEAN: // fall through
132 case T_INT : return new IntConstant (value.as_int ());
133 case T_LONG : return new LongConstant (value.as_long ());
134 case T_FLOAT : return new FloatConstant (value.as_float ());
135 case T_DOUBLE : return new DoubleConstant(value.as_double());
136 case T_ARRAY : // fall through (ciConstant doesn't have an array accessor)
137 case T_OBJECT : return new ObjectConstant(value.as_object());
138 }
139 ShouldNotReachHere();
140 return illegalType;
141 }
142
143
144 BasicType as_BasicType(ValueType* type) {
145 switch (type->tag()) {
146 case voidTag: return T_VOID;
147 case intTag: return T_INT;
148 case longTag: return T_LONG;
149 case floatTag: return T_FLOAT;
150 case doubleTag: return T_DOUBLE;
151 case objectTag: return T_OBJECT;
152 case addressTag: return T_ADDRESS;
153 case illegalTag: return T_ILLEGAL;
154 }
155 ShouldNotReachHere();
156 return T_ILLEGAL;
157 }