1 /*

     2  * Copyright (c) 1997, 2017, 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/javaClasses.hpp"

    27 #include "classfile/moduleEntry.hpp"

    28 #include "classfile/packageEntry.hpp"

    29 #include "classfile/stringTable.hpp"

    30 #include "classfile/systemDictionary.hpp"

    31 #include "classfile/verifier.hpp"

    32 #include "classfile/vmSymbols.hpp"

    33 #include "interpreter/linkResolver.hpp"

    34 #include "memory/oopFactory.hpp"

    35 #include "memory/resourceArea.hpp"

    36 #include "memory/universe.inline.hpp"

    37 #include "oops/instanceKlass.hpp"

    38 #include "oops/objArrayKlass.hpp"

    39 #include "oops/objArrayOop.inline.hpp"

    40 #include "oops/oop.inline.hpp"

    41 #include "prims/jvm.h"

    42 #include "prims/jvmtiExport.hpp"

    43 #include "runtime/arguments.hpp"

    44 #include "runtime/handles.inline.hpp"

    45 #include "runtime/javaCalls.hpp"

    46 #include "runtime/reflection.hpp"

    47 #include "runtime/reflectionUtils.hpp"

    48 #include "runtime/signature.hpp"

    49 #include "runtime/vframe.hpp"

    50 

    51 static void trace_class_resolution(const Klass* to_class) {

    52   ResourceMark rm;

    53   int line_number = -1;

    54   const char * source_file = NULL;

    55   Klass* caller = NULL;

    56   JavaThread* jthread = JavaThread::current();

    57   if (jthread->has_last_Java_frame()) {

    58     vframeStream vfst(jthread);

    59     // skip over any frames belonging to java.lang.Class

    60     while (!vfst.at_end() &&

    61            vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class()) {

    62       vfst.next();

    63     }

    64     if (!vfst.at_end()) {

    65       // this frame is a likely suspect

    66       caller = vfst.method()->method_holder();

    67       line_number = vfst.method()->line_number_from_bci(vfst.bci());

    68       Symbol* s = vfst.method()->method_holder()->source_file_name();

    69       if (s != NULL) {

    70         source_file = s->as_C_string();

    71       }

    72     }

    73   }

    74   if (caller != NULL) {

    75     const char * from = caller->external_name();

    76     const char * to = to_class->external_name();

    77     // print in a single call to reduce interleaving between threads

    78     if (source_file != NULL) {

    79       log_debug(class, resolve)("%s %s %s:%d (reflection)", from, to, source_file, line_number);

    80     } else {

    81       log_debug(class, resolve)("%s %s (reflection)", from, to);

    82     }

    83   }

    84 }

    85 

    86 

    87 oop Reflection::box(jvalue* value, BasicType type, TRAPS) {

    88   if (type == T_VOID) {

    89     return NULL;

    90   }

    91   if (type == T_OBJECT || type == T_ARRAY) {

    92     // regular objects are not boxed

    93     return (oop) value->l;

    94   }

    95   oop result = java_lang_boxing_object::create(type, value, CHECK_NULL);

    96   if (result == NULL) {

    97     THROW_(vmSymbols::java_lang_IllegalArgumentException(), result);

    98   }

    99   return result;

   100 }

   101 

   102 

   103 BasicType Reflection::unbox_for_primitive(oop box, jvalue* value, TRAPS) {

   104   if (box == NULL) {

   105     THROW_(vmSymbols::java_lang_IllegalArgumentException(), T_ILLEGAL);

   106   }

   107   return java_lang_boxing_object::get_value(box, value);

   108 }

   109 

   110 BasicType Reflection::unbox_for_regular_object(oop box, jvalue* value) {

   111   // Note:  box is really the unboxed oop.  It might even be a Short, etc.!

   112   value->l = (jobject) box;

   113   return T_OBJECT;

   114 }

   115 

   116 

   117 void Reflection::widen(jvalue* value, BasicType current_type, BasicType wide_type, TRAPS) {

   118   assert(wide_type != current_type, "widen should not be called with identical types");

   119   switch (wide_type) {

   120     case T_BOOLEAN:

   121     case T_BYTE:

   122     case T_CHAR:

   123       break;  // fail

   124     case T_SHORT:

   125       switch (current_type) {

   126         case T_BYTE:

   127           value->s = (jshort) value->b;

   128           return;

   129         default:

   130           break;

   131       }

   132       break;  // fail

   133     case T_INT:

   134       switch (current_type) {

   135         case T_BYTE:

   136           value->i = (jint) value->b;

   137           return;

   138         case T_CHAR:

   139           value->i = (jint) value->c;

   140           return;

   141         case T_SHORT:

   142           value->i = (jint) value->s;

   143           return;

   144         default:

   145           break;

   146       }

   147       break;  // fail

   148     case T_LONG:

   149       switch (current_type) {

   150         case T_BYTE:

   151           value->j = (jlong) value->b;

   152           return;

   153         case T_CHAR:

   154           value->j = (jlong) value->c;

   155           return;

   156         case T_SHORT:

   157           value->j = (jlong) value->s;

   158           return;

   159         case T_INT:

   160           value->j = (jlong) value->i;

   161           return;

   162         default:

   163           break;

   164       }

   165       break;  // fail

   166     case T_FLOAT:

   167       switch (current_type) {

   168         case T_BYTE:

   169           value->f = (jfloat) value->b;

   170           return;

   171         case T_CHAR:

   172           value->f = (jfloat) value->c;

   173           return;

   174         case T_SHORT:

   175           value->f = (jfloat) value->s;

   176           return;

   177         case T_INT:

   178           value->f = (jfloat) value->i;

   179           return;

   180         case T_LONG:

   181           value->f = (jfloat) value->j;

   182           return;

   183         default:

   184           break;

   185       }

   186       break;  // fail

   187     case T_DOUBLE:

   188       switch (current_type) {

   189         case T_BYTE:

   190           value->d = (jdouble) value->b;

   191           return;

   192         case T_CHAR:

   193           value->d = (jdouble) value->c;

   194           return;

   195         case T_SHORT:

   196           value->d = (jdouble) value->s;

   197           return;

   198         case T_INT:

   199           value->d = (jdouble) value->i;

   200           return;

   201         case T_FLOAT:

   202           value->d = (jdouble) value->f;

   203           return;

   204         case T_LONG:

   205           value->d = (jdouble) value->j;

   206           return;

   207         default:

   208           break;

   209       }

   210       break;  // fail

   211     default:

   212       break;  // fail

   213   }

   214   THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "argument type mismatch");

   215 }

   216 

   217 

   218 BasicType Reflection::array_get(jvalue* value, arrayOop a, int index, TRAPS) {

   219   if (!a->is_within_bounds(index)) {

   220     THROW_(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), T_ILLEGAL);

   221   }

   222   if (a->is_objArray()) {

   223     value->l = (jobject) objArrayOop(a)->obj_at(index);

   224     return T_OBJECT;

   225   } else {

   226     assert(a->is_typeArray(), "just checking");

   227     BasicType type = TypeArrayKlass::cast(a->klass())->element_type();

   228     switch (type) {

   229       case T_BOOLEAN:

   230         value->z = typeArrayOop(a)->bool_at(index);

   231         break;

   232       case T_CHAR:

   233         value->c = typeArrayOop(a)->char_at(index);

   234         break;

   235       case T_FLOAT:

   236         value->f = typeArrayOop(a)->float_at(index);

   237         break;

   238       case T_DOUBLE:

   239         value->d = typeArrayOop(a)->double_at(index);

   240         break;

   241       case T_BYTE:

   242         value->b = typeArrayOop(a)->byte_at(index);

   243         break;

   244       case T_SHORT:

   245         value->s = typeArrayOop(a)->short_at(index);

   246         break;

   247       case T_INT:

   248         value->i = typeArrayOop(a)->int_at(index);

   249         break;

   250       case T_LONG:

   251         value->j = typeArrayOop(a)->long_at(index);

   252         break;

   253       default:

   254         return T_ILLEGAL;

   255     }

   256     return type;

   257   }

   258 }

   259 

   260 

   261 void Reflection::array_set(jvalue* value, arrayOop a, int index, BasicType value_type, TRAPS) {

   262   if (!a->is_within_bounds(index)) {

   263     THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());

   264   }

   265   if (a->is_objArray()) {

   266     if (value_type == T_OBJECT) {

   267       oop obj = (oop) value->l;

   268       if (obj != NULL) {

   269         Klass* element_klass = ObjArrayKlass::cast(a->klass())->element_klass();

   270         if (!obj->is_a(element_klass)) {

   271           THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "array element type mismatch");

   272         }

   273       }

   274       objArrayOop(a)->obj_at_put(index, obj);

   275     }

   276   } else {

   277     assert(a->is_typeArray(), "just checking");

   278     BasicType array_type = TypeArrayKlass::cast(a->klass())->element_type();

   279     if (array_type != value_type) {

   280       // The widen operation can potentially throw an exception, but cannot block,

   281       // so typeArrayOop a is safe if the call succeeds.

   282       widen(value, value_type, array_type, CHECK);

   283     }

   284     switch (array_type) {

   285       case T_BOOLEAN:

   286         typeArrayOop(a)->bool_at_put(index, value->z);

   287         break;

   288       case T_CHAR:

   289         typeArrayOop(a)->char_at_put(index, value->c);

   290         break;

   291       case T_FLOAT:

   292         typeArrayOop(a)->float_at_put(index, value->f);

   293         break;

   294       case T_DOUBLE:

   295         typeArrayOop(a)->double_at_put(index, value->d);

   296         break;

   297       case T_BYTE:

   298         typeArrayOop(a)->byte_at_put(index, value->b);

   299         break;

   300       case T_SHORT:

   301         typeArrayOop(a)->short_at_put(index, value->s);

   302         break;

   303       case T_INT:

   304         typeArrayOop(a)->int_at_put(index, value->i);

   305         break;

   306       case T_LONG:

   307         typeArrayOop(a)->long_at_put(index, value->j);

   308         break;

   309       default:

   310         THROW(vmSymbols::java_lang_IllegalArgumentException());

   311     }

   312   }

   313 }

   314 

   315 static Klass* basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS) {

   316   assert(java_lang_Class::is_primitive(basic_type_mirror), "just checking");

   317   BasicType type = java_lang_Class::primitive_type(basic_type_mirror);

   318   if (type == T_VOID) {

   319     THROW_0(vmSymbols::java_lang_IllegalArgumentException());

   320   }

   321   else {

   322     return Universe::typeArrayKlassObj(type);

   323   }

   324 }

   325 

   326 #ifdef ASSERT

   327 static oop basic_type_arrayklass_to_mirror(Klass* basic_type_arrayklass, TRAPS) {

   328   BasicType type = TypeArrayKlass::cast(basic_type_arrayklass)->element_type();

   329   return Universe::java_mirror(type);

   330 }

   331 #endif

   332 

   333 arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {

   334   if (element_mirror == NULL) {

   335     THROW_0(vmSymbols::java_lang_NullPointerException());

   336   }

   337   if (length < 0) {

   338     THROW_0(vmSymbols::java_lang_NegativeArraySizeException());

   339   }

   340   if (java_lang_Class::is_primitive(element_mirror)) {

   341     Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);

   342     return TypeArrayKlass::cast(tak)->allocate(length, THREAD);

   343   } else {

   344     Klass* k = java_lang_Class::as_Klass(element_mirror);

   345     if (k->is_array_klass() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {

   346       THROW_0(vmSymbols::java_lang_IllegalArgumentException());

   347     }

   348     return oopFactory::new_objArray(k, length, THREAD);

   349   }

   350 }

   351 

   352 

   353 arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop dim_array, TRAPS) {

   354   assert(dim_array->is_typeArray(), "just checking");

   355   assert(TypeArrayKlass::cast(dim_array->klass())->element_type() == T_INT, "just checking");

   356 

   357   if (element_mirror == NULL) {

   358     THROW_0(vmSymbols::java_lang_NullPointerException());

   359   }

   360 

   361   int len = dim_array->length();

   362   if (len <= 0 || len > MAX_DIM) {

   363     THROW_0(vmSymbols::java_lang_IllegalArgumentException());

   364   }

   365 

   366   jint dimensions[MAX_DIM];   // C array copy of intArrayOop

   367   for (int i = 0; i < len; i++) {

   368     int d = dim_array->int_at(i);

   369     if (d < 0) {

   370       THROW_0(vmSymbols::java_lang_NegativeArraySizeException());

   371     }

   372     dimensions[i] = d;

   373   }

   374 

   375   Klass* klass;

   376   int dim = len;

   377   if (java_lang_Class::is_primitive(element_mirror)) {

   378     klass = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);

   379   } else {

   380     klass = java_lang_Class::as_Klass(element_mirror);

   381     if (klass->is_array_klass()) {

   382       int k_dim = ArrayKlass::cast(klass)->dimension();

   383       if (k_dim + len > MAX_DIM) {

   384         THROW_0(vmSymbols::java_lang_IllegalArgumentException());

   385       }

   386       dim += k_dim;

   387     }

   388   }

   389   klass = klass->array_klass(dim, CHECK_NULL);

   390   oop obj = ArrayKlass::cast(klass)->multi_allocate(len, dimensions, CHECK_NULL);

   391   assert(obj->is_array(), "just checking");

   392   return arrayOop(obj);

   393 }

   394 

   395 

   396 oop Reflection::array_component_type(oop mirror, TRAPS) {

   397   if (java_lang_Class::is_primitive(mirror)) {

   398     return NULL;

   399   }

   400 

   401   Klass* klass = java_lang_Class::as_Klass(mirror);

   402   if (!klass->is_array_klass()) {

   403     return NULL;

   404   }

   405 

   406   oop result = java_lang_Class::component_mirror(mirror);

   407 #ifdef ASSERT

   408   oop result2 = NULL;

   409   if (ArrayKlass::cast(klass)->dimension() == 1) {

   410     if (klass->is_typeArray_klass()) {

   411       result2 = basic_type_arrayklass_to_mirror(klass, CHECK_NULL);

   412     } else {

   413       result2 = ObjArrayKlass::cast(klass)->element_klass()->java_mirror();

   414     }

   415   } else {

   416     Klass* lower_dim = ArrayKlass::cast(klass)->lower_dimension();

   417     assert(lower_dim->is_array_klass(), "just checking");

   418     result2 = lower_dim->java_mirror();

   419   }

   420   assert(result == result2, "results must be consistent");

   421 #endif //ASSERT

   422   return result;

   423 }

   424 

   425 static bool under_host_klass(const InstanceKlass* ik, const InstanceKlass* host_klass) {

   426   DEBUG_ONLY(int inf_loop_check = 1000 * 1000 * 1000);

   427   for (;;) {

   428     const InstanceKlass* hc = ik->host_klass();

   429     if (hc == NULL)        return false;

   430     if (hc == host_klass)  return true;

   431     ik = hc;

   432 

   433     // There's no way to make a host class loop short of patching memory.

   434     // Therefore there cannot be a loop here unless there's another bug.

   435     // Still, let's check for it.

   436     assert(--inf_loop_check > 0, "no host_klass loop");

   437   }

   438 }

   439 

   440 static bool can_relax_access_check_for(const Klass* accessor,

   441                                        const Klass* accessee,

   442                                        bool classloader_only) {

   443 

   444   const InstanceKlass* accessor_ik = InstanceKlass::cast(accessor);

   445   const InstanceKlass* accessee_ik = InstanceKlass::cast(accessee);

   446 

   447   // If either is on the other's host_klass chain, access is OK,

   448   // because one is inside the other.

   449   if (under_host_klass(accessor_ik, accessee_ik) ||

   450     under_host_klass(accessee_ik, accessor_ik))

   451     return true;

   452 

   453   if ((RelaxAccessControlCheck &&

   454     accessor_ik->major_version() < Verifier::NO_RELAX_ACCESS_CTRL_CHECK_VERSION &&

   455     accessee_ik->major_version() < Verifier::NO_RELAX_ACCESS_CTRL_CHECK_VERSION) ||

   456     (accessor_ik->major_version() < Verifier::STRICTER_ACCESS_CTRL_CHECK_VERSION &&

   457     accessee_ik->major_version() < Verifier::STRICTER_ACCESS_CTRL_CHECK_VERSION)) {

   458     return classloader_only &&

   459       Verifier::relax_access_for(accessor_ik->class_loader()) &&

   460       accessor_ik->protection_domain() == accessee_ik->protection_domain() &&

   461       accessor_ik->class_loader() == accessee_ik->class_loader();

   462   }

   463 

   464   return false;

   465 }

   466 

   467 /*

   468     Type Accessibility check for public types: Callee Type T is accessible to Caller Type S if:

   469 

   470                         Callee T in             Callee T in package PT,

   471                         unnamed module          runtime module MT

   472  ------------------------------------------------------------------------------------------------

   473 

   474  Caller S in package     If MS is loose: YES      If same classloader/package (PS == PT): YES

   475  PS, runtime module MS   If MS can read T's       If same runtime module: (MS == MT): YES

   476                          unnamed module: YES

   477                                                   Else if (MS can read MT (establish readability) &&

   478                                                     ((MT exports PT to MS or to all modules) ||

   479                                                      (MT is open))): YES

   480 

   481  ------------------------------------------------------------------------------------------------

   482  Caller S in unnamed         YES                  Readability exists because unnamed module

   483  module UM                                            "reads" all modules

   484                                                   if (MT exports PT to UM or to all modules): YES

   485 

   486  ------------------------------------------------------------------------------------------------

   487 

   488  Note: a loose module is a module that can read all current and future unnamed modules.

   489 */

   490 Reflection::VerifyClassAccessResults Reflection::verify_class_access(

   491   const Klass* current_class, const InstanceKlass* new_class, bool classloader_only) {

   492 

   493   // Verify that current_class can access new_class.  If the classloader_only

   494   // flag is set, we automatically allow any accesses in which current_class

   495   // doesn't have a classloader.

   496   if ((current_class == NULL) ||

   497       (current_class == new_class) ||

   498       is_same_class_package(current_class, new_class)) {

   499     return ACCESS_OK;

   500   }

   501   // Allow all accesses from jdk/internal/reflect/MagicAccessorImpl subclasses to

   502   // succeed trivially.

   503   if (current_class->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {

   504     return ACCESS_OK;

   505   }

   506 

   507   // module boundaries

   508   if (new_class->is_public()) {

   509     // Ignore modules for DumpSharedSpaces because we do not have any package

   510     // or module information for modules other than java.base.

   511     if (DumpSharedSpaces) {

   512       return ACCESS_OK;

   513     }

   514 

   515     // Find the module entry for current_class, the accessor

   516     ModuleEntry* module_from = current_class->module();

   517     // Find the module entry for new_class, the accessee

   518     ModuleEntry* module_to = new_class->module();

   519 

   520     // both in same (possibly unnamed) module

   521     if (module_from == module_to) {

   522       return ACCESS_OK;

   523     }

   524 

   525     // Acceptable access to a type in an unnamed module. Note that since

   526     // unnamed modules can read all unnamed modules, this also handles the

   527     // case where module_from is also unnamed but in a different class loader.

   528     if (!module_to->is_named() &&

   529         (module_from->can_read_all_unnamed() || module_from->can_read(module_to))) {

   530       return ACCESS_OK;

   531     }

   532 

   533     // Establish readability, check if module_from is allowed to read module_to.

   534     if (!module_from->can_read(module_to)) {

   535       return MODULE_NOT_READABLE;

   536     }

   537 

   538     // Access is allowed if module_to is open, i.e. all its packages are unqualifiedly exported

   539     if (module_to->is_open()) {

   540       return ACCESS_OK;

   541     }

   542 

   543     PackageEntry* package_to = new_class->package();

   544     assert(package_to != NULL, "can not obtain new_class' package");

   545 

   546     {

   547       MutexLocker m1(Module_lock);

   548 

   549       // Once readability is established, if module_to exports T unqualifiedly,

   550       // (to all modules), than whether module_from is in the unnamed module

   551       // or not does not matter, access is allowed.

   552       if (package_to->is_unqual_exported()) {

   553         return ACCESS_OK;

   554       }

   555 

   556       // Access is allowed if both 1 & 2 hold:

   557       //   1. Readability, module_from can read module_to (established above).

   558       //   2. Either module_to exports T to module_from qualifiedly.

   559       //      or

   560       //      module_to exports T to all unnamed modules and module_from is unnamed.

   561       //      or

   562       //      module_to exports T unqualifiedly to all modules (checked above).

   563       if (!package_to->is_qexported_to(module_from)) {

   564         return TYPE_NOT_EXPORTED;

   565       }

   566     }

   567     return ACCESS_OK;

   568   }

   569 

   570   if (can_relax_access_check_for(current_class, new_class, classloader_only)) {

   571     return ACCESS_OK;

   572   }

   573   return OTHER_PROBLEM;

   574 }

   575 

   576 // Return an error message specific to the specified Klass*'s and result.

   577 // This function must be called from within a block containing a ResourceMark.

   578 char* Reflection::verify_class_access_msg(const Klass* current_class,

   579                                           const InstanceKlass* new_class,

   580                                           const VerifyClassAccessResults result) {

   581   assert(result != ACCESS_OK, "must be failure result");

   582   char * msg = NULL;

   583   if (result != OTHER_PROBLEM && new_class != NULL && current_class != NULL) {

   584     // Find the module entry for current_class, the accessor

   585     ModuleEntry* module_from = current_class->module();

   586     const char * module_from_name = module_from->is_named() ? module_from->name()->as_C_string() : UNNAMED_MODULE;

   587     const char * current_class_name = current_class->external_name();

   588 

   589     // Find the module entry for new_class, the accessee

   590     ModuleEntry* module_to = NULL;

   591     module_to = new_class->module();

   592     const char * module_to_name = module_to->is_named() ? module_to->name()->as_C_string() : UNNAMED_MODULE;

   593     const char * new_class_name = new_class->external_name();

   594 

   595     if (result == MODULE_NOT_READABLE) {

   596       assert(module_from->is_named(), "Unnamed modules can read all modules");

   597       if (module_to->is_named()) {

   598         size_t len = 100 + strlen(current_class_name) + 2*strlen(module_from_name) +

   599           strlen(new_class_name) + 2*strlen(module_to_name);

   600         msg = NEW_RESOURCE_ARRAY(char, len);

   601         jio_snprintf(msg, len - 1,

   602           "class %s (in module %s) cannot access class %s (in module %s) because module %s does not read module %s",

   603           current_class_name, module_from_name, new_class_name,

   604           module_to_name, module_from_name, module_to_name);

   605       } else {

   606         oop jlm = module_to->module();

   607         assert(jlm != NULL, "Null jlm in module_to ModuleEntry");

   608         intptr_t identity_hash = jlm->identity_hash();

   609         size_t len = 160 + strlen(current_class_name) + 2*strlen(module_from_name) +

   610           strlen(new_class_name) + 2*sizeof(uintx);

   611         msg = NEW_RESOURCE_ARRAY(char, len);

   612         jio_snprintf(msg, len - 1,

   613           "class %s (in module %s) cannot access class %s (in unnamed module @" SIZE_FORMAT_HEX ") because module %s does not read unnamed module @" SIZE_FORMAT_HEX,

   614           current_class_name, module_from_name, new_class_name, uintx(identity_hash),

   615           module_from_name, uintx(identity_hash));

   616       }

   617 

   618     } else if (result == TYPE_NOT_EXPORTED) {

   619       assert(new_class->package() != NULL,

   620              "Unnamed packages are always exported");

   621       const char * package_name =

   622         new_class->package()->name()->as_klass_external_name();

   623       assert(module_to->is_named(), "Unnamed modules export all packages");

   624       if (module_from->is_named()) {

   625         size_t len = 118 + strlen(current_class_name) + 2*strlen(module_from_name) +

   626           strlen(new_class_name) + 2*strlen(module_to_name) + strlen(package_name);

   627         msg = NEW_RESOURCE_ARRAY(char, len);

   628         jio_snprintf(msg, len - 1,

   629           "class %s (in module %s) cannot access class %s (in module %s) because module %s does not export %s to module %s",

   630           current_class_name, module_from_name, new_class_name,

   631           module_to_name, module_to_name, package_name, module_from_name);

   632       } else {

   633         oop jlm = module_from->module();

   634         assert(jlm != NULL, "Null jlm in module_from ModuleEntry");

   635         intptr_t identity_hash = jlm->identity_hash();

   636         size_t len = 170 + strlen(current_class_name) + strlen(new_class_name) +

   637           2*strlen(module_to_name) + strlen(package_name) + 2*sizeof(uintx);

   638         msg = NEW_RESOURCE_ARRAY(char, len);

   639         jio_snprintf(msg, len - 1,

   640           "class %s (in unnamed module @" SIZE_FORMAT_HEX ") cannot access class %s (in module %s) because module %s does not export %s to unnamed module @" SIZE_FORMAT_HEX,

   641           current_class_name, uintx(identity_hash), new_class_name, module_to_name,

   642           module_to_name, package_name, uintx(identity_hash));

   643       }

   644     } else {

   645         ShouldNotReachHere();

   646     }

   647   }  // result != OTHER_PROBLEM...

   648   return msg;

   649 }

   650 

   651 bool Reflection::verify_field_access(const Klass* current_class,

   652                                      const Klass* resolved_class,

   653                                      const Klass* field_class,

   654                                      AccessFlags access,

   655                                      bool classloader_only,

   656                                      bool protected_restriction) {

   657   // Verify that current_class can access a field of field_class, where that

   658   // field's access bits are "access".  We assume that we've already verified

   659   // that current_class can access field_class.

   660   //

   661   // If the classloader_only flag is set, we automatically allow any accesses

   662   // in which current_class doesn't have a classloader.

   663   //

   664   // "resolved_class" is the runtime type of "field_class". Sometimes we don't

   665   // need this distinction (e.g. if all we have is the runtime type, or during

   666   // class file parsing when we only care about the static type); in that case

   667   // callers should ensure that resolved_class == field_class.

   668   //

   669   if ((current_class == NULL) ||

   670       (current_class == field_class) ||

   671       access.is_public()) {

   672     return true;

   673   }

   674 

   675   const Klass* host_class = current_class;

   676   if (host_class->is_instance_klass() &&

   677       InstanceKlass::cast(host_class)->is_anonymous()) {

   678     host_class = InstanceKlass::cast(host_class)->host_klass();

   679     assert(host_class != NULL, "Anonymous class has null host class");

   680     assert(!(host_class->is_instance_klass() &&

   681            InstanceKlass::cast(host_class)->is_anonymous()),

   682            "host_class should not be anonymous");

   683   }

   684   if (host_class == field_class) {

   685     return true;

   686   }

   687 

   688   if (access.is_protected()) {

   689     if (!protected_restriction) {

   690       // See if current_class (or outermost host class) is a subclass of field_class

   691       // An interface may not access protected members of j.l.Object

   692       if (!host_class->is_interface() && host_class->is_subclass_of(field_class)) {

   693         if (access.is_static() || // static fields are ok, see 6622385

   694             current_class == resolved_class ||

   695             field_class == resolved_class ||

   696             host_class->is_subclass_of(resolved_class) ||

   697             resolved_class->is_subclass_of(host_class)) {

   698           return true;

   699         }

   700       }

   701     }

   702   }

   703 

   704   if (!access.is_private() && is_same_class_package(current_class, field_class)) {

   705     return true;

   706   }

   707 

   708   // Allow all accesses from jdk/internal/reflect/MagicAccessorImpl subclasses to

   709   // succeed trivially.

   710   if (current_class->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {

   711     return true;

   712   }

   713 

   714   return can_relax_access_check_for(

   715     current_class, field_class, classloader_only);

   716 }

   717 

   718 bool Reflection::is_same_class_package(const Klass* class1, const Klass* class2) {

   719   return InstanceKlass::cast(class1)->is_same_class_package(class2);

   720 }

   721 

   722 // Checks that the 'outer' klass has declared 'inner' as being an inner klass. If not,

   723 // throw an incompatible class change exception

   724 // If inner_is_member, require the inner to be a member of the outer.

   725 // If !inner_is_member, require the inner to be anonymous (a non-member).

   726 // Caller is responsible for figuring out in advance which case must be true.

   727 void Reflection::check_for_inner_class(const InstanceKlass* outer, const InstanceKlass* inner,

   728                                        bool inner_is_member, TRAPS) {

   729   InnerClassesIterator iter(outer);

   730   constantPoolHandle cp   (THREAD, outer->constants());

   731   for (; !iter.done(); iter.next()) {

   732      int ioff = iter.inner_class_info_index();

   733      int ooff = iter.outer_class_info_index();

   734 

   735      if (inner_is_member && ioff != 0 && ooff != 0) {

   736         Klass* o = cp->klass_at(ooff, CHECK);

   737         if (o == outer) {

   738           Klass* i = cp->klass_at(ioff, CHECK);

   739           if (i == inner) {

   740             return;

   741           }

   742         }

   743      }

   744      if (!inner_is_member && ioff != 0 && ooff == 0 &&

   745          cp->klass_name_at_matches(inner, ioff)) {

   746         Klass* i = cp->klass_at(ioff, CHECK);

   747         if (i == inner) {

   748           return;

   749         }

   750      }

   751   }

   752 

   753   // 'inner' not declared as an inner klass in outer

   754   ResourceMark rm(THREAD);

   755   Exceptions::fthrow(

   756     THREAD_AND_LOCATION,

   757     vmSymbols::java_lang_IncompatibleClassChangeError(),

   758     "%s and %s disagree on InnerClasses attribute",

   759     outer->external_name(),

   760     inner->external_name()

   761   );

   762 }

   763 

   764 // Utility method converting a single SignatureStream element into java.lang.Class instance

   765 static oop get_mirror_from_signature(const methodHandle& method,

   766                                      SignatureStream* ss,

   767                                      TRAPS) {

   768 

   769 

   770   if (T_OBJECT == ss->type() || T_ARRAY == ss->type()) {

   771     Symbol* name = ss->as_symbol(CHECK_NULL);

   772     oop loader = method->method_holder()->class_loader();

   773     oop protection_domain = method->method_holder()->protection_domain();

   774     const Klass* k = SystemDictionary::resolve_or_fail(name,

   775                                                        Handle(THREAD, loader),

   776                                                        Handle(THREAD, protection_domain),

   777                                                        true,

   778                                                        CHECK_NULL);

   779     if (log_is_enabled(Debug, class, resolve)) {

   780       trace_class_resolution(k);

   781     }

   782     return k->java_mirror();

   783   }

   784 

   785   assert(ss->type() != T_VOID || ss->at_return_type(),

   786     "T_VOID should only appear as return type");

   787 

   788   return java_lang_Class::primitive_mirror(ss->type());

   789 }

   790 

   791 static objArrayHandle get_parameter_types(const methodHandle& method,

   792                                           int parameter_count,

   793                                           oop* return_type,

   794                                           TRAPS) {

   795   // Allocate array holding parameter types (java.lang.Class instances)

   796   objArrayOop m = oopFactory::new_objArray(SystemDictionary::Class_klass(), parameter_count, CHECK_(objArrayHandle()));

   797   objArrayHandle mirrors(THREAD, m);

   798   int index = 0;

   799   // Collect parameter types

   800   ResourceMark rm(THREAD);

   801   Symbol*  signature = method->signature();

   802   SignatureStream ss(signature);

   803   while (!ss.at_return_type()) {

   804     oop mirror = get_mirror_from_signature(method, &ss, CHECK_(objArrayHandle()));

   805     mirrors->obj_at_put(index++, mirror);

   806     ss.next();

   807   }

   808   assert(index == parameter_count, "invalid parameter count");

   809   if (return_type != NULL) {

   810     // Collect return type as well

   811     assert(ss.at_return_type(), "return type should be present");

   812     *return_type = get_mirror_from_signature(method, &ss, CHECK_(objArrayHandle()));

   813   }

   814   return mirrors;

   815 }

   816 

   817 static objArrayHandle get_exception_types(const methodHandle& method, TRAPS) {

   818   return method->resolved_checked_exceptions(THREAD);

   819 }

   820 

   821 static Handle new_type(Symbol* signature, Klass* k, TRAPS) {

   822   // Basic types

   823   BasicType type = vmSymbols::signature_type(signature);

   824   if (type != T_OBJECT) {

   825     return Handle(THREAD, Universe::java_mirror(type));

   826   }

   827 

   828   Klass* result =

   829     SystemDictionary::resolve_or_fail(signature,

   830                                       Handle(THREAD, k->class_loader()),

   831                                       Handle(THREAD, k->protection_domain()),

   832                                       true, CHECK_(Handle()));

   833 

   834   if (log_is_enabled(Debug, class, resolve)) {

   835     trace_class_resolution(result);

   836   }

   837 

   838   oop nt = result->java_mirror();

   839   return Handle(THREAD, nt);

   840 }

   841 

   842 

   843 oop Reflection::new_method(const methodHandle& method, bool for_constant_pool_access, TRAPS) {

   844   // Allow sun.reflect.ConstantPool to refer to <clinit> methods as java.lang.reflect.Methods.

   845   assert(!method()->is_initializer() ||

   846          (for_constant_pool_access && method()->is_static()),

   847          "should call new_constructor instead");

   848   InstanceKlass* holder = method->method_holder();

   849   int slot = method->method_idnum();

   850 

   851   Symbol*  signature  = method->signature();

   852   int parameter_count = ArgumentCount(signature).size();

   853   oop return_type_oop = NULL;

   854   objArrayHandle parameter_types = get_parameter_types(method, parameter_count, &return_type_oop, CHECK_NULL);

   855   if (parameter_types.is_null() || return_type_oop == NULL) return NULL;

   856 

   857   Handle return_type(THREAD, return_type_oop);

   858 

   859   objArrayHandle exception_types = get_exception_types(method, CHECK_NULL);

   860 

   861   if (exception_types.is_null()) return NULL;

   862 

   863   Symbol*  method_name = method->name();

   864   oop name_oop = StringTable::intern(method_name, CHECK_NULL);

   865   Handle name = Handle(THREAD, name_oop);

   866   if (name == NULL) return NULL;

   867 

   868   const int modifiers = method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;

   869 

   870   Handle mh = java_lang_reflect_Method::create(CHECK_NULL);

   871 

   872   java_lang_reflect_Method::set_clazz(mh(), holder->java_mirror());

   873   java_lang_reflect_Method::set_slot(mh(), slot);

   874   java_lang_reflect_Method::set_name(mh(), name());

   875   java_lang_reflect_Method::set_return_type(mh(), return_type());

   876   java_lang_reflect_Method::set_parameter_types(mh(), parameter_types());

   877   java_lang_reflect_Method::set_exception_types(mh(), exception_types());

   878   java_lang_reflect_Method::set_modifiers(mh(), modifiers);

   879   java_lang_reflect_Method::set_override(mh(), false);

   880   if (java_lang_reflect_Method::has_signature_field() &&

   881       method->generic_signature() != NULL) {

   882     Symbol*  gs = method->generic_signature();

   883     Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);

   884     java_lang_reflect_Method::set_signature(mh(), sig());

   885   }

   886   if (java_lang_reflect_Method::has_annotations_field()) {

   887     typeArrayOop an_oop = Annotations::make_java_array(method->annotations(), CHECK_NULL);

   888     java_lang_reflect_Method::set_annotations(mh(), an_oop);

   889   }

   890   if (java_lang_reflect_Method::has_parameter_annotations_field()) {

   891     typeArrayOop an_oop = Annotations::make_java_array(method->parameter_annotations(), CHECK_NULL);

   892     java_lang_reflect_Method::set_parameter_annotations(mh(), an_oop);

   893   }

   894   if (java_lang_reflect_Method::has_annotation_default_field()) {

   895     typeArrayOop an_oop = Annotations::make_java_array(method->annotation_default(), CHECK_NULL);

   896     java_lang_reflect_Method::set_annotation_default(mh(), an_oop);

   897   }

   898   if (java_lang_reflect_Method::has_type_annotations_field()) {

   899     typeArrayOop an_oop = Annotations::make_java_array(method->type_annotations(), CHECK_NULL);

   900     java_lang_reflect_Method::set_type_annotations(mh(), an_oop);

   901   }

   902   return mh();

   903 }

   904 

   905 

   906 oop Reflection::new_constructor(const methodHandle& method, TRAPS) {

   907   assert(method()->is_initializer(), "should call new_method instead");

   908 

   909   InstanceKlass* holder = method->method_holder();

   910   int slot = method->method_idnum();

   911 

   912   Symbol*  signature  = method->signature();

   913   int parameter_count = ArgumentCount(signature).size();

   914   objArrayHandle parameter_types = get_parameter_types(method, parameter_count, NULL, CHECK_NULL);

   915   if (parameter_types.is_null()) return NULL;

   916 

   917   objArrayHandle exception_types = get_exception_types(method, CHECK_NULL);

   918   if (exception_types.is_null()) return NULL;

   919 

   920   const int modifiers = method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;

   921 

   922   Handle ch = java_lang_reflect_Constructor::create(CHECK_NULL);

   923 

   924   java_lang_reflect_Constructor::set_clazz(ch(), holder->java_mirror());

   925   java_lang_reflect_Constructor::set_slot(ch(), slot);

   926   java_lang_reflect_Constructor::set_parameter_types(ch(), parameter_types());

   927   java_lang_reflect_Constructor::set_exception_types(ch(), exception_types());

   928   java_lang_reflect_Constructor::set_modifiers(ch(), modifiers);

   929   java_lang_reflect_Constructor::set_override(ch(), false);

   930   if (java_lang_reflect_Constructor::has_signature_field() &&

   931       method->generic_signature() != NULL) {

   932     Symbol*  gs = method->generic_signature();

   933     Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);

   934     java_lang_reflect_Constructor::set_signature(ch(), sig());

   935   }

   936   if (java_lang_reflect_Constructor::has_annotations_field()) {

   937     typeArrayOop an_oop = Annotations::make_java_array(method->annotations(), CHECK_NULL);

   938     java_lang_reflect_Constructor::set_annotations(ch(), an_oop);

   939   }

   940   if (java_lang_reflect_Constructor::has_parameter_annotations_field()) {

   941     typeArrayOop an_oop = Annotations::make_java_array(method->parameter_annotations(), CHECK_NULL);

   942     java_lang_reflect_Constructor::set_parameter_annotations(ch(), an_oop);

   943   }

   944   if (java_lang_reflect_Constructor::has_type_annotations_field()) {

   945     typeArrayOop an_oop = Annotations::make_java_array(method->type_annotations(), CHECK_NULL);

   946     java_lang_reflect_Constructor::set_type_annotations(ch(), an_oop);

   947   }

   948   return ch();

   949 }

   950 

   951 

   952 oop Reflection::new_field(fieldDescriptor* fd, TRAPS) {

   953   Symbol*  field_name = fd->name();

   954   oop name_oop = StringTable::intern(field_name, CHECK_NULL);

   955   Handle name = Handle(THREAD, name_oop);

   956   Symbol*  signature  = fd->signature();

   957   InstanceKlass* holder = fd->field_holder();

   958   Handle type = new_type(signature, holder, CHECK_NULL);

   959   Handle rh  = java_lang_reflect_Field::create(CHECK_NULL);

   960 

   961   java_lang_reflect_Field::set_clazz(rh(), fd->field_holder()->java_mirror());

   962   java_lang_reflect_Field::set_slot(rh(), fd->index());

   963   java_lang_reflect_Field::set_name(rh(), name());

   964   java_lang_reflect_Field::set_type(rh(), type());

   965   // Note the ACC_ANNOTATION bit, which is a per-class access flag, is never set here.

   966   java_lang_reflect_Field::set_modifiers(rh(), fd->access_flags().as_int() & JVM_RECOGNIZED_FIELD_MODIFIERS);

   967   java_lang_reflect_Field::set_override(rh(), false);

   968   if (java_lang_reflect_Field::has_signature_field() &&

   969       fd->has_generic_signature()) {

   970     Symbol*  gs = fd->generic_signature();

   971     Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);

   972     java_lang_reflect_Field::set_signature(rh(), sig());

   973   }

   974   if (java_lang_reflect_Field::has_annotations_field()) {

   975     typeArrayOop an_oop = Annotations::make_java_array(fd->annotations(), CHECK_NULL);

   976     java_lang_reflect_Field::set_annotations(rh(), an_oop);

   977   }

   978   if (java_lang_reflect_Field::has_type_annotations_field()) {

   979     typeArrayOop an_oop = Annotations::make_java_array(fd->type_annotations(), CHECK_NULL);

   980     java_lang_reflect_Field::set_type_annotations(rh(), an_oop);

   981   }

   982   return rh();

   983 }

   984 

   985 oop Reflection::new_parameter(Handle method, int index, Symbol* sym,

   986                               int flags, TRAPS) {

   987 

   988   Handle rh = java_lang_reflect_Parameter::create(CHECK_NULL);

   989 

   990   if(NULL != sym) {

   991     Handle name = java_lang_String::create_from_symbol(sym, CHECK_NULL);

   992     java_lang_reflect_Parameter::set_name(rh(), name());

   993   } else {

   994     java_lang_reflect_Parameter::set_name(rh(), NULL);

   995   }

   996 

   997   java_lang_reflect_Parameter::set_modifiers(rh(), flags);

   998   java_lang_reflect_Parameter::set_executable(rh(), method());

   999   java_lang_reflect_Parameter::set_index(rh(), index);

  1000   return rh();

  1001 }

  1002 

  1003 

  1004 static methodHandle resolve_interface_call(InstanceKlass* klass,

  1005                                            const methodHandle& method,

  1006                                            Klass* recv_klass,

  1007                                            Handle receiver,

  1008                                            TRAPS) {

  1009 

  1010   assert(!method.is_null() , "method should not be null");

  1011 

  1012   CallInfo info;

  1013   Symbol*  signature  = method->signature();

  1014   Symbol*  name       = method->name();

  1015   LinkResolver::resolve_interface_call(info, receiver, recv_klass,

  1016                                        LinkInfo(klass, name, signature),

  1017                                        true,

  1018                                        CHECK_(methodHandle()));

  1019   return info.selected_method();

  1020 }

  1021 

  1022 // Conversion

  1023 static BasicType basic_type_mirror_to_basic_type(oop basic_type_mirror, TRAPS) {

  1024   assert(java_lang_Class::is_primitive(basic_type_mirror),

  1025     "just checking");

  1026   return java_lang_Class::primitive_type(basic_type_mirror);

  1027 }

  1028 

  1029 // Narrowing of basic types. Used to create correct jvalues for

  1030 // boolean, byte, char and short return return values from interpreter

  1031 // which are returned as ints. Throws IllegalArgumentException.

  1032 static void narrow(jvalue* value, BasicType narrow_type, TRAPS) {

  1033   switch (narrow_type) {

  1034   case T_BOOLEAN:

  1035     value->z = (jboolean) (value->i & 1);

  1036     return;

  1037   case T_BYTE:

  1038     value->b = (jbyte)value->i;

  1039     return;

  1040   case T_CHAR:

  1041     value->c = (jchar)value->i;

  1042     return;

  1043   case T_SHORT:

  1044     value->s = (jshort)value->i;

  1045     return;

  1046   default:

  1047     break; // fail

  1048   }

  1049   THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "argument type mismatch");

  1050 }

  1051 

  1052 

  1053 // Method call (shared by invoke_method and invoke_constructor)

  1054 static oop invoke(InstanceKlass* klass,

  1055                   const methodHandle& reflected_method,

  1056                   Handle receiver,

  1057                   bool override,

  1058                   objArrayHandle ptypes,

  1059                   BasicType rtype,

  1060                   objArrayHandle args,

  1061                   bool is_method_invoke,

  1062                   TRAPS) {

  1063 

  1064   ResourceMark rm(THREAD);

  1065 

  1066   methodHandle method;      // actual method to invoke

  1067   Klass* target_klass;      // target klass, receiver's klass for non-static

  1068 

  1069   // Ensure klass is initialized

  1070   klass->initialize(CHECK_NULL);

  1071 

  1072   bool is_static = reflected_method->is_static();

  1073   if (is_static) {

  1074     // ignore receiver argument

  1075     method = reflected_method;

  1076     target_klass = klass;

  1077   } else {

  1078     // check for null receiver

  1079     if (receiver.is_null()) {

  1080       THROW_0(vmSymbols::java_lang_NullPointerException());

  1081     }

  1082     // Check class of receiver against class declaring method

  1083     if (!receiver->is_a(klass)) {

  1084       THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "object is not an instance of declaring class");

  1085     }

  1086     // target klass is receiver's klass

  1087     target_klass = receiver->klass();

  1088     // no need to resolve if method is private or <init>

  1089     if (reflected_method->is_private() || reflected_method->name() == vmSymbols::object_initializer_name()) {

  1090       method = reflected_method;

  1091     } else {

  1092       // resolve based on the receiver

  1093       if (reflected_method->method_holder()->is_interface()) {

  1094         // resolve interface call

  1095         //

  1096         // Match resolution errors with those thrown due to reflection inlining

  1097         // Linktime resolution & IllegalAccessCheck already done by Class.getMethod()

  1098         method = resolve_interface_call(klass, reflected_method, target_klass, receiver, THREAD);

  1099         if (HAS_PENDING_EXCEPTION) {

  1100           // Method resolution threw an exception; wrap it in an InvocationTargetException

  1101           oop resolution_exception = PENDING_EXCEPTION;

  1102           CLEAR_PENDING_EXCEPTION;

  1103           // JVMTI has already reported the pending exception

  1104           // JVMTI internal flag reset is needed in order to report InvocationTargetException

  1105           if (THREAD->is_Java_thread()) {

  1106             JvmtiExport::clear_detected_exception((JavaThread*)THREAD);

  1107           }

  1108           JavaCallArguments args(Handle(THREAD, resolution_exception));

  1109           THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),

  1110                       vmSymbols::throwable_void_signature(),

  1111                       &args);

  1112         }

  1113       }  else {

  1114         // if the method can be overridden, we resolve using the vtable index.

  1115         assert(!reflected_method->has_itable_index(), "");

  1116         int index = reflected_method->vtable_index();

  1117         method = reflected_method;

  1118         if (index != Method::nonvirtual_vtable_index) {

  1119           method = methodHandle(THREAD, target_klass->method_at_vtable(index));

  1120         }

  1121         if (!method.is_null()) {

  1122           // Check for abstract methods as well

  1123           if (method->is_abstract()) {

  1124             // new default: 6531596

  1125             ResourceMark rm(THREAD);

  1126             Handle h_origexception = Exceptions::new_exception(THREAD,

  1127               vmSymbols::java_lang_AbstractMethodError(),

  1128               Method::name_and_sig_as_C_string(target_klass,

  1129               method->name(),

  1130               method->signature()));

  1131             JavaCallArguments args(h_origexception);

  1132             THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),

  1133               vmSymbols::throwable_void_signature(),

  1134               &args);