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