hotspot/src/share/vm/memory/oopFactory.cpp
changeset 1894 5c343868d071
parent 1 489c9b5090e2
child 2006 f2d2f0f20063
equal deleted inserted replaced
1893:c82e388e17c5 1894:5c343868d071
    80   // initialization not needed, allocated cleared
    80   // initialization not needed, allocated cleared
    81   return o;
    81   return o;
    82 }
    82 }
    83 
    83 
    84 
    84 
    85 constantPoolOop oopFactory::new_constantPool(int length, TRAPS) {
    85 constantPoolOop oopFactory::new_constantPool(int length,
       
    86                                              bool is_conc_safe,
       
    87                                              TRAPS) {
    86   constantPoolKlass* ck = constantPoolKlass::cast(Universe::constantPoolKlassObj());
    88   constantPoolKlass* ck = constantPoolKlass::cast(Universe::constantPoolKlassObj());
    87   return ck->allocate(length, CHECK_NULL);
    89   return ck->allocate(length, is_conc_safe, CHECK_NULL);
    88 }
    90 }
    89 
    91 
    90 
    92 
    91 constantPoolCacheOop oopFactory::new_constantPoolCache(int length, TRAPS) {
    93 constantPoolCacheOop oopFactory::new_constantPoolCache(int length, TRAPS) {
    92   constantPoolCacheKlass* ck = constantPoolCacheKlass::cast(Universe::constantPoolCacheKlassObj());
    94   constantPoolCacheKlass* ck = constantPoolCacheKlass::cast(Universe::constantPoolCacheKlassObj());
   103 
   105 
   104 constMethodOop oopFactory::new_constMethod(int byte_code_size,
   106 constMethodOop oopFactory::new_constMethod(int byte_code_size,
   105                                            int compressed_line_number_size,
   107                                            int compressed_line_number_size,
   106                                            int localvariable_table_length,
   108                                            int localvariable_table_length,
   107                                            int checked_exceptions_length,
   109                                            int checked_exceptions_length,
       
   110                                            bool is_conc_safe,
   108                                            TRAPS) {
   111                                            TRAPS) {
   109   klassOop cmkObj = Universe::constMethodKlassObj();
   112   klassOop cmkObj = Universe::constMethodKlassObj();
   110   constMethodKlass* cmk = constMethodKlass::cast(cmkObj);
   113   constMethodKlass* cmk = constMethodKlass::cast(cmkObj);
   111   return cmk->allocate(byte_code_size, compressed_line_number_size,
   114   return cmk->allocate(byte_code_size, compressed_line_number_size,
   112                        localvariable_table_length, checked_exceptions_length,
   115                        localvariable_table_length, checked_exceptions_length,
       
   116                        is_conc_safe,
   113                        CHECK_NULL);
   117                        CHECK_NULL);
   114 }
   118 }
   115 
   119 
   116 
   120 
   117 methodOop oopFactory::new_method(int byte_code_size, AccessFlags access_flags,
   121 methodOop oopFactory::new_method(int byte_code_size, AccessFlags access_flags,
   118                                  int compressed_line_number_size,
   122                                  int compressed_line_number_size,
   119                                  int localvariable_table_length,
   123                                  int localvariable_table_length,
   120                                  int checked_exceptions_length, TRAPS) {
   124                                  int checked_exceptions_length,
       
   125                                  bool is_conc_safe,
       
   126                                  TRAPS) {
   121   methodKlass* mk = methodKlass::cast(Universe::methodKlassObj());
   127   methodKlass* mk = methodKlass::cast(Universe::methodKlassObj());
   122   assert(!access_flags.is_native() || byte_code_size == 0,
   128   assert(!access_flags.is_native() || byte_code_size == 0,
   123          "native methods should not contain byte codes");
   129          "native methods should not contain byte codes");
   124   constMethodOop cm = new_constMethod(byte_code_size,
   130   constMethodOop cm = new_constMethod(byte_code_size,
   125                                       compressed_line_number_size,
   131                                       compressed_line_number_size,
   126                                       localvariable_table_length,
   132                                       localvariable_table_length,
   127                                       checked_exceptions_length, CHECK_NULL);
   133                                       checked_exceptions_length,
       
   134                                       is_conc_safe, CHECK_NULL);
   128   constMethodHandle rw(THREAD, cm);
   135   constMethodHandle rw(THREAD, cm);
   129   return mk->allocate(rw, access_flags, CHECK_NULL);
   136   return mk->allocate(rw, access_flags, CHECK_NULL);
   130 }
   137 }
   131 
   138 
   132 
   139