c1_ValueType.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 "c1/c1_ValueType.hpp"
27#include "ci/ciArray.hpp"
28#include "ci/ciInstance.hpp"
29#include "ci/ciNullObject.hpp"
30
31
32// predefined types
33VoidType*       voidType     = NULL;
34IntType*        intType      = NULL;
35LongType*       longType     = NULL;
36FloatType*      floatType    = NULL;
37DoubleType*     doubleType   = NULL;
38ObjectType*     objectType   = NULL;
39ArrayType*      arrayType    = NULL;
40InstanceType*   instanceType = NULL;
41ClassType*      classType    = NULL;
42AddressType*    addressType  = NULL;
43IllegalType*    illegalType  = NULL;
44
45
46// predefined constants
47IntConstant*    intZero      = NULL;
48IntConstant*    intOne       = NULL;
49ObjectConstant* objectNull   = NULL;
50
51
52void 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
75ValueType* 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
82ValueType* ValueType::join(ValueType* y) const {
83  Unimplemented();
84  return NULL;
85}
86
87
88ciType* ObjectConstant::exact_type() const {
89  ciObject* c = constant_value();
90  return (c != NULL && !c->is_null_object()) ? c->klass() : NULL;
91}
92ciType* ArrayConstant::exact_type() const {
93  ciObject* c = constant_value();
94  return (c != NULL && !c->is_null_object()) ? c->klass() : NULL;
95}
96ciType* InstanceConstant::exact_type() const {
97  ciObject* c = constant_value();
98  return (c != NULL && !c->is_null_object()) ? c->klass() : NULL;
99}
100ciType* ClassConstant::exact_type() const {
101  return Compilation::current()->env()->Class_klass();
102}
103
104
105jobject ObjectType::encoding() const {
106  assert(is_constant(), "must be");
107  return constant_value()->constant_encoding();
108}
109
110bool ObjectType::is_loaded() const {
111  assert(is_constant(), "must be");
112  return constant_value()->is_loaded();
113}
114
115bool MetadataType::is_loaded() const {
116  assert(is_constant(), "must be");
117  return constant_value()->is_loaded();
118}
119
120ciObject* ObjectConstant::constant_value() const                   { return _value; }
121ciObject* ArrayConstant::constant_value() const                    { return _value; }
122ciObject* InstanceConstant::constant_value() const                 { return _value; }
123
124ValueType* as_ValueType(BasicType type) {
125  switch (type) {
126    case T_VOID   : return voidType;
127    case T_BYTE   : // fall through
128    case T_CHAR   : // fall through
129    case T_SHORT  : // fall through
130    case T_BOOLEAN: // fall through
131    case T_INT    : return intType;
132    case T_LONG   : return longType;
133    case T_FLOAT  : return floatType;
134    case T_DOUBLE : return doubleType;
135    case T_ARRAY  : return arrayType;
136    case T_OBJECT : return objectType;
137    case T_ADDRESS: return addressType;
138    case T_ILLEGAL: return illegalType;
139  }
140  ShouldNotReachHere();
141  return illegalType;
142}
143
144
145ValueType* as_ValueType(ciConstant value) {
146  switch (value.basic_type()) {
147    case T_BYTE   : // fall through
148    case T_CHAR   : // fall through
149    case T_SHORT  : // fall through
150    case T_BOOLEAN: // fall through
151    case T_INT    : return new IntConstant   (value.as_int   ());
152    case T_LONG   : return new LongConstant  (value.as_long  ());
153    case T_FLOAT  : return new FloatConstant (value.as_float ());
154    case T_DOUBLE : return new DoubleConstant(value.as_double());
155    case T_ARRAY  : // fall through (ciConstant doesn't have an array accessor)
156    case T_OBJECT : return new ObjectConstant(value.as_object());
157  }
158  ShouldNotReachHere();
159  return illegalType;
160}
161
162
163BasicType as_BasicType(ValueType* type) {
164  switch (type->tag()) {
165    case voidTag:    return T_VOID;
166    case intTag:     return T_INT;
167    case longTag:    return T_LONG;
168    case floatTag:   return T_FLOAT;
169    case doubleTag:  return T_DOUBLE;
170    case objectTag:  return T_OBJECT;
171    case addressTag: return T_ADDRESS;
172    case illegalTag: return T_ILLEGAL;
173  }
174  ShouldNotReachHere();
175  return T_ILLEGAL;
176}
177