jdk8-mips64-public/hotspot: src/share/vm/c1/c1

7016023: Enable building ARM and PPC from src/closed repository
Reviewed-by: dholmes, bdelsart

     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  */

    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"

    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;

    46 // predefined constants

    47 IntConstant*    intZero      = NULL;

    48 IntConstant*    intOne       = NULL;

    49 ObjectConstant* objectNull   = NULL;

    52 void ValueType::initialize(Arena* arena) {

    53   // Note: Must initialize all types for each compilation

    54   //       as they are allocated within a ResourceMark!

    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();

    69   intZero     = new (arena) IntConstant(0);

    70   intOne      = new (arena) IntConstant(1);

    71   objectNull  = new (arena) ObjectConstant(ciNullObject::make());

    72 };

    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 }

    82 ValueType* ValueType::join(ValueType* y) const {

    83   Unimplemented();

    84   return NULL;

    85 }

    89 jobject ObjectType::encoding() const {

    90   assert(is_constant(), "must be");

    91   return constant_value()->constant_encoding();

    92 }

    94 bool ObjectType::is_loaded() const {

    95   assert(is_constant(), "must be");

    96   return constant_value()->is_loaded();

    97 }

    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; }

   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 }

   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 }

   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 }

src/share/vm/c1/c1_ValueType.cpp@b92c45f2bc75