hotspot/src/share/vm/memory/oopFactory.cpp
author tonyp
Tue, 08 Nov 2011 00:41:28 -0500
changeset 10997 0be4b3be7197
parent 10566 630c177ec580
child 12369 48fd3da4025c
permissions -rw-r--r--
7099849: G1: include heap region information in hs_err files Reviewed-by: johnc, brutisso, poonam
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8337
diff changeset
     2
 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3694
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3694
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3694
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#include "classfile/javaClasses.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
#include "classfile/symbolTable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "classfile/vmSymbols.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "gc_interface/collectedHeap.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    31
#include "memory/oopFactory.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    33
#include "memory/universe.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    34
#include "oops/compiledICHolderKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#include "oops/constMethodKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    36
#include "oops/constantPoolKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    37
#include "oops/cpCacheKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    38
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    39
#include "oops/instanceKlassKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    40
#include "oops/instanceOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    41
#include "oops/klassKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    42
#include "oops/klassOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    43
#include "oops/methodDataKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    44
#include "oops/methodKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    45
#include "oops/objArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    46
#include "oops/oop.inline.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  int length = utf8_str == NULL ? 0 : UTF8::unicode_length(utf8_str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  typeArrayOop result = new_charArray(length, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  if (length > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
    UTF8::convert_to_unicode(utf8_str, result->char_at_addr(0), length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
typeArrayOop oopFactory::new_permanent_charArray(int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  return typeArrayKlass::cast(Universe::charArrayKlassObj())->allocate_permanent(length, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
typeArrayOop oopFactory::new_permanent_byteArray(int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  return typeArrayKlass::cast(Universe::byteArrayKlassObj())->allocate_permanent(length, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
typeArrayOop oopFactory::new_permanent_shortArray(int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  return typeArrayKlass::cast(Universe::shortArrayKlassObj())->allocate_permanent(length, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
typeArrayOop oopFactory::new_permanent_intArray(int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  return typeArrayKlass::cast(Universe::intArrayKlassObj())->allocate_permanent(length, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  klassOop type_asKlassOop = Universe::typeArrayKlassObj(type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop);
10566
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 8725
diff changeset
    80
  typeArrayOop result = type_asArrayKlass->allocate_common(length, true, THREAD);
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 8725
diff changeset
    81
  return result;
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 8725
diff changeset
    82
}
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 8725
diff changeset
    83
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 8725
diff changeset
    84
typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS) {
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 8725
diff changeset
    85
  klassOop type_asKlassOop = Universe::typeArrayKlassObj(type);
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 8725
diff changeset
    86
  typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop);
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 8725
diff changeset
    87
  typeArrayOop result = type_asArrayKlass->allocate_common(length, false, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
objArrayOop oopFactory::new_objArray(klassOop klass, int length, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  assert(klass->is_klass(), "must be instance class");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  if (klass->klass_part()->oop_is_array()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    return ((arrayKlass*)klass->klass_part())->allocate_arrayArray(1, length, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    assert (klass->klass_part()->oop_is_instance(), "new object array with klass not an instanceKlass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    return ((instanceKlass*)klass->klass_part())->allocate_objArray(1, length, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
8337
ccb1f3acfe94 7020992: jmm_DumpThreads should not allocate system object arrays outside the perm gen
stefank
parents: 8300
diff changeset
   102
objArrayOop oopFactory::new_system_objArray(int length, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  int size = objArrayOopDesc::object_size(length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  KlassHandle klass (THREAD, Universe::systemObjArrayKlassObj());
8337
ccb1f3acfe94 7020992: jmm_DumpThreads should not allocate system object arrays outside the perm gen
stefank
parents: 8300
diff changeset
   105
  objArrayOop o = (objArrayOop)
ccb1f3acfe94 7020992: jmm_DumpThreads should not allocate system object arrays outside the perm gen
stefank
parents: 8300
diff changeset
   106
    Universe::heap()->permanent_array_allocate(klass, size, length, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // initialization not needed, allocated cleared
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  return o;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
1894
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   112
constantPoolOop oopFactory::new_constantPool(int length,
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   113
                                             bool is_conc_safe,
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   114
                                             TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  constantPoolKlass* ck = constantPoolKlass::cast(Universe::constantPoolKlassObj());
1894
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   116
  return ck->allocate(length, is_conc_safe, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
2006
f2d2f0f20063 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents: 1894
diff changeset
   120
constantPoolCacheOop oopFactory::new_constantPoolCache(int length,
f2d2f0f20063 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents: 1894
diff changeset
   121
                                                       TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  constantPoolCacheKlass* ck = constantPoolCacheKlass::cast(Universe::constantPoolCacheKlassObj());
8296
b1c2163e4e59 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 7397
diff changeset
   123
  return ck->allocate(length, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8337
diff changeset
   127
klassOop oopFactory::new_instanceKlass(Symbol* name, int vtable_len, int itable_len,
3694
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   128
                                       int static_field_size,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   129
                                       unsigned int nonstatic_oop_map_count,
942b7bc7f28c 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 3693
diff changeset
   130
                                       ReferenceType rt, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  instanceKlassKlass* ikk = instanceKlassKlass::cast(Universe::instanceKlassKlassObj());
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8337
diff changeset
   132
  return ikk->allocate_instance_klass(name, vtable_len, itable_len, static_field_size, nonstatic_oop_map_count, rt, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
constMethodOop oopFactory::new_constMethod(int byte_code_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
                                           int compressed_line_number_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
                                           int localvariable_table_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
                                           int checked_exceptions_length,
1894
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   140
                                           bool is_conc_safe,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
                                           TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  klassOop cmkObj = Universe::constMethodKlassObj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  constMethodKlass* cmk = constMethodKlass::cast(cmkObj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  return cmk->allocate(byte_code_size, compressed_line_number_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
                       localvariable_table_length, checked_exceptions_length,
1894
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   146
                       is_conc_safe,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
                       CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
methodOop oopFactory::new_method(int byte_code_size, AccessFlags access_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
                                 int compressed_line_number_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
                                 int localvariable_table_length,
1894
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   154
                                 int checked_exceptions_length,
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   155
                                 bool is_conc_safe,
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   156
                                 TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  methodKlass* mk = methodKlass::cast(Universe::methodKlassObj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  assert(!access_flags.is_native() || byte_code_size == 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
         "native methods should not contain byte codes");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  constMethodOop cm = new_constMethod(byte_code_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
                                      compressed_line_number_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
                                      localvariable_table_length,
1894
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   163
                                      checked_exceptions_length,
5c343868d071 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 1
diff changeset
   164
                                      is_conc_safe, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  constMethodHandle rw(THREAD, cm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  return mk->allocate(rw, access_flags, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
methodDataOop oopFactory::new_methodData(methodHandle method, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  methodDataKlass* mdk = methodDataKlass::cast(Universe::methodDataKlassObj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  return mdk->allocate(method, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
compiledICHolderOop oopFactory::new_compiledICHolder(methodHandle method, KlassHandle klass, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  compiledICHolderKlass* ck = (compiledICHolderKlass*) Universe::compiledICHolderKlassObj()->klass_part();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  compiledICHolderOop c = ck->allocate(CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  c->set_holder_method(method());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  c->set_holder_klass(klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  return c;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
}