1 /*
   2  * Copyright (c) 1997, 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 "classfile/systemDictionary.hpp"
  27 #include "classfile/vmSymbols.hpp"
  28 #include "memory/resourceArea.hpp"
  29 #include "memory/universe.inline.hpp"
  30 #include "oops/instanceKlass.hpp"
  31 #include "oops/fieldStreams.hpp"
  32 #include "runtime/fieldDescriptor.hpp"
  33 #include "runtime/handles.inline.hpp"
  34 #include "runtime/signature.hpp"
  35 
  36 
  37 oop fieldDescriptor::loader() const {
  38   return instanceKlass::cast(_cp->pool_holder())->class_loader();
  39 }
  40 
  41 Symbol* fieldDescriptor::generic_signature() const {
  42   if (!access_flags().field_has_generic_signature()) {
  43     return NULL;
  44   }
  45 
  46   int idx = 0;
  47   instanceKlass* ik = instanceKlass::cast(field_holder());
  48   for (AllFieldStream fs(ik); !fs.done(); fs.next()) {
  49     if (idx == _index) {
  50       return fs.generic_signature();
  51     } else {
  52       idx ++;
  53     }
  54   }
  55   assert(false, "should never happen");
  56   return NULL;
  57 }
  58 
  59 typeArrayOop fieldDescriptor::annotations() const {
  60   instanceKlass* ik = instanceKlass::cast(field_holder());
  61   objArrayOop md = ik->fields_annotations();
  62   if (md == NULL)
  63     return NULL;
  64   return typeArrayOop(md->obj_at(index()));
  65 }
  66 
  67 constantTag fieldDescriptor::initial_value_tag() const {
  68   return constants()->tag_at(initial_value_index());
  69 }
  70 
  71 jint fieldDescriptor::int_initial_value() const {
  72   return constants()->int_at(initial_value_index());
  73 }
  74 
  75 jlong fieldDescriptor::long_initial_value() const {
  76   return constants()->long_at(initial_value_index());
  77 }
  78 
  79 jfloat fieldDescriptor::float_initial_value() const {
  80   return constants()->float_at(initial_value_index());
  81 }
  82 
  83 jdouble fieldDescriptor::double_initial_value() const {
  84   return constants()->double_at(initial_value_index());
  85 }
  86 
  87 oop fieldDescriptor::string_initial_value(TRAPS) const {
  88   return constants()->string_at(initial_value_index(), CHECK_0);
  89 }
  90 
  91 void fieldDescriptor::initialize(klassOop k, int index) {
  92   instanceKlass* ik = instanceKlass::cast(k);
  93   _cp = ik->constants();
  94   FieldInfo* f = ik->field(index);
  95   assert(!f->is_internal(), "regular Java fields only");
  96 
  97   _access_flags = accessFlags_from(f->access_flags());
  98   guarantee(f->name_index() != 0 && f->signature_index() != 0, "bad constant pool index for fieldDescriptor");
  99   _index = index;
 100 }
 101 
 102 #ifndef PRODUCT
 103 
 104 void fieldDescriptor::print_on(outputStream* st) const {
 105   access_flags().print_on(st);
 106   name()->print_value_on(st);
 107   st->print(" ");
 108   signature()->print_value_on(st);
 109   st->print(" @%d ", offset());
 110   if (WizardMode && has_initial_value()) {
 111     st->print("(initval ");
 112     constantTag t = initial_value_tag();
 113     if (t.is_int()) {
 114       st->print("int %d)", int_initial_value());
 115     } else if (t.is_long()){
 116       st->print_jlong(long_initial_value());
 117     } else if (t.is_float()){
 118       st->print("float %f)", float_initial_value());
 119     } else if (t.is_double()){
 120       st->print("double %lf)", double_initial_value());
 121     }
 122   }
 123 }
 124 
 125 void fieldDescriptor::print_on_for(outputStream* st, oop obj) {
 126   print_on(st);
 127   BasicType ft = field_type();
 128   jint as_int = 0;
 129   switch (ft) {
 130     case T_BYTE:
 131       as_int = (jint)obj->byte_field(offset());
 132       st->print(" %d", obj->byte_field(offset()));
 133       break;
 134     case T_CHAR:
 135       as_int = (jint)obj->char_field(offset());
 136       {
 137         jchar c = obj->char_field(offset());
 138         as_int = c;
 139         st->print(" %c %d", isprint(c) ? c : ' ', c);
 140       }
 141       break;
 142     case T_DOUBLE:
 143       st->print(" %lf", obj->double_field(offset()));
 144       break;
 145     case T_FLOAT:
 146       as_int = obj->int_field(offset());
 147       st->print(" %f", obj->float_field(offset()));
 148       break;
 149     case T_INT:
 150       as_int = obj->int_field(offset());
 151       st->print(" %d", obj->int_field(offset()));
 152       break;
 153     case T_LONG:
 154       st->print(" ");
 155       st->print_jlong(obj->long_field(offset()));
 156       break;
 157     case T_SHORT:
 158       as_int = obj->short_field(offset());
 159       st->print(" %d", obj->short_field(offset()));
 160       break;
 161     case T_BOOLEAN:
 162       as_int = obj->bool_field(offset());
 163       st->print(" %s", obj->bool_field(offset()) ? "true" : "false");
 164       break;
 165     case T_ARRAY:
 166       st->print(" ");
 167       NOT_LP64(as_int = obj->int_field(offset()));
 168       obj->obj_field(offset())->print_value_on(st);
 169       break;
 170     case T_OBJECT:
 171       st->print(" ");
 172       NOT_LP64(as_int = obj->int_field(offset()));
 173       obj->obj_field(offset())->print_value_on(st);
 174       break;
 175     default:
 176       ShouldNotReachHere();
 177       break;
 178   }
 179   // Print a hint as to the underlying integer representation. This can be wrong for
 180   // pointers on an LP64 machine
 181   if (ft == T_LONG || ft == T_DOUBLE LP64_ONLY(|| !is_java_primitive(ft)) ) {
 182     st->print(" (%x %x)", obj->int_field(offset()), obj->int_field(offset()+sizeof(jint)));
 183   } else if (as_int < 0 || as_int > 9) {
 184     st->print(" (%x)", as_int);
 185   }
 186 }
 187 
 188 #endif /* PRODUCT */