001/* 002 * This file is part of the Jikes RVM project (http://jikesrvm.org). 003 * 004 * This file is licensed to You under the Eclipse Public License (EPL); 005 * You may not use this file except in compliance with the License. You 006 * may obtain a copy of the License at 007 * 008 * http://www.opensource.org/licenses/eclipse-1.0.php 009 * 010 * See the COPYRIGHT.txt file distributed with this work for information 011 * regarding copyright ownership. 012 */ 013package org.jikesrvm.mm.mminterface; 014 015import static org.jikesrvm.classloader.RVMType.REFARRAY_OFFSET_ARRAY; 016import static org.jikesrvm.objectmodel.JavaHeaderConstants.FIELD_ZERO_OFFSET; 017import static org.jikesrvm.runtime.UnboxedSizeConstants.LOG_BYTES_IN_ADDRESS; 018 019import org.jikesrvm.VM; 020import org.jikesrvm.classloader.Atom; 021import org.jikesrvm.classloader.RVMClass; 022import org.jikesrvm.classloader.RVMMethod; 023import org.jikesrvm.classloader.RVMType; 024import org.jikesrvm.classloader.SpecializedMethod; 025import org.jikesrvm.classloader.TypeReference; 026import org.jikesrvm.compilers.common.CodeArray; 027import org.jikesrvm.compilers.common.CompiledMethod; 028import org.jikesrvm.objectmodel.ObjectModel; 029import org.jikesrvm.runtime.Magic; 030import org.mmtk.plan.TransitiveClosure; 031import org.vmmagic.pragma.Inline; 032import org.vmmagic.pragma.Interruptible; 033import org.vmmagic.pragma.NoInline; 034import org.vmmagic.pragma.SpecializedMethodInvoke; 035import org.vmmagic.pragma.Uninterruptible; 036import org.vmmagic.unboxed.Address; 037import org.vmmagic.unboxed.ObjectReference; 038 039/** 040 * A method that scan objects and is specialized to a specific MMTk 041 * TransitiveClosure type. 042 * <p> 043 * In general as there may not be a 1-1 mapping between objects and the 044 * specialized methods this class is responsible for performing the 045 * mapping. 046 * <p> 047 * Specialized methods must have a static 'invoke' method that matches 048 * the given signature and return type. 049 */ 050@Uninterruptible 051public final class SpecializedScanMethod extends SpecializedMethod { 052 053 /** Use specialized scanning ? */ 054 public static final boolean ENABLED = true; 055 056 /** This method's signature: the object to be scanned and the trace to use */ 057 private static final TypeReference[] signature = new TypeReference[] { 058 TypeReference.JavaLangObject, 059 TypeReference.findOrCreate(TransitiveClosure.class)}; 060 061 /** The return type of this method: void */ 062 private static final TypeReference returnType = TypeReference.Void; 063 064 /** Our type reference */ 065 private static final TypeReference specializedScanMethodType = TypeReference.findOrCreate(SpecializedScanMethod.class); 066 067 /** Objects with no references or primitive arrays */ 068 private static final int NULL_PATTERN = 0; 069 /** Number of patterns we will specialize */ 070 private static final int SPECIALIZED_PATTERNS = 64; 071 /** Reference arrays */ 072 private static final int REFARRAY_PATTERN = 64; 073 /** Fallback to a slower path that is not specialized */ 074 private static final int FALLBACK_PATTERN = 65; 075 /** The total number of patterns */ 076 private static final int PATTERNS = 66; 077 /** Maximum field offset we can deal with */ 078 private static final int MAX_SPECIALIZED_OFFSET = 6 << LOG_BYTES_IN_ADDRESS; 079 080 /** We keep the specialized methods for key object reference patterns here.*/ 081 private final CompiledMethod[] specializedMethods = new CompiledMethod[PATTERNS]; 082 083 /** The specialized signature of the method */ 084 private final TypeReference[] specializedSignature; 085 086 public SpecializedScanMethod(int id, TypeReference specializedTrace) { 087 super(id); 088 this.specializedSignature = new TypeReference[] { TypeReference.JavaLangObject, specializedTrace }; 089 090 if (!VM.BuildWithBaseBootImageCompiler) { 091 /* Compile our specialized methods when we are opt compiling */ 092 RVMClass myClass = specializedScanMethodType.peekType().asClass(); 093 for (int i = 0; i < PATTERNS; i++) { 094 RVMMethod method = myClass.findStaticMethod(templateMethodName(i), specializedMethodDescriptor); 095 specializedMethods[i] = compileSpecializedMethod(method, specializedSignature); 096 } 097 } 098 } 099 100 /** 101 * @param type the type to scan 102 * @return the index for the given pattern 103 */ 104 @Interruptible 105 private static int getPattern(RVMType type) { 106 /* Handle array types */ 107 if (type.isArrayType()) { 108 if (type.asArray().getElementType().isReferenceType()) { 109 return REFARRAY_PATTERN; 110 } 111 return NULL_PATTERN; 112 } 113 114 /* Build a bitmap if the object is compact enough and is not a reference array */ 115 int[] offsets = type.getReferenceOffsets(); 116 117 if (VM.VerifyAssertions) VM._assert(offsets != null); 118 119 if (offsets.length == 0) { 120 return NULL_PATTERN; 121 } 122 if ((offsets.length << LOG_BYTES_IN_ADDRESS) > SPECIALIZED_PATTERNS) { 123 return FALLBACK_PATTERN; 124 } 125 126 int base = FIELD_ZERO_OFFSET.toInt(); 127 int pattern = 0; 128 129 for (int i = 0; i < offsets.length; i++) { 130 int reference = (offsets[i] - base); 131 if (reference > MAX_SPECIALIZED_OFFSET) { 132 return FALLBACK_PATTERN; 133 } 134 pattern |= 1 << (reference >> LOG_BYTES_IN_ADDRESS); 135 } 136 137 if (pattern < 0 || pattern > 63) { 138 pattern = FALLBACK_PATTERN; 139 } 140 141 return pattern; 142 } 143 144 /** 145 * TODO: Lazily compile specialized methods? 146 */ 147 @Override 148 @Interruptible 149 public synchronized CodeArray specializeMethod(RVMType type) { 150 /* Work out which pattern this type uses */ 151 int pattern = getPattern(type); 152 153 if (VM.BuildWithBaseBootImageCompiler) { 154 /* There is no point specializing if we aren't opt compiling */ 155 return null; 156 } 157 158 /* Ensure we have a compiled method cached. */ 159 if (VM.VerifyAssertions) VM._assert(specializedMethods[pattern] != null); 160 161 /* Return the code entry array */ 162 return specializedMethods[pattern].getEntryCodeArray(); 163 } 164 165 @Override 166 public TypeReference[] getSignature() { 167 return signature; 168 } 169 170 @Override 171 public TypeReference getReturnType() { 172 return returnType; 173 } 174 175 /** 176 * This method performs the scanning of a given object. 177 * <p> 178 * This is the method that (may) be hijacked by the compiler to call the specialized method. 179 * <p> 180 * It is safe for a compiler to ignore the potential gains and just use this method 181 * directly. 182 * 183 * @param id The specialized method id 184 * @param object The object to scan 185 * @param trace The trace to scan 186 */ 187 @SpecializedMethodInvoke 188 @NoInline 189 public static void invoke(int id, Object object, TransitiveClosure trace) { 190 /* By default we call a non-specialized fallback */ 191 fallback(object, trace); 192 } 193 194 public static void fallback(Object object, TransitiveClosure trace) { 195 ObjectReference objectRef = ObjectReference.fromObject(object); 196 RVMType type = ObjectModel.getObjectType(objectRef.toObject()); 197 int[] offsets = type.getReferenceOffsets(); 198 if (offsets != REFARRAY_OFFSET_ARRAY) { 199 if (VM.VerifyAssertions) VM._assert(type.isClassType() || (type.isArrayType() && !type.asArray().getElementType().isReferenceType())); 200 for (int i = 0; i < offsets.length; i++) { 201 trace.processEdge(objectRef, objectRef.toAddress().plus(offsets[i])); 202 } 203 } else { 204 if (VM.VerifyAssertions) VM._assert(type.isArrayType() && type.asArray().getElementType().isReferenceType()); 205 for (int i = 0; i < ObjectModel.getArrayLength(objectRef.toObject()); i++) { 206 trace.processEdge(objectRef, objectRef.toAddress().plus(i << LOG_BYTES_IN_ADDRESS)); 207 } 208 } 209 } 210 211 // All Scalars 212 public static void scalar(Object object, TransitiveClosure trace) { 213 Address base = Magic.objectAsAddress(object); 214 int[] offsets = ObjectModel.getObjectType(object).getReferenceOffsets(); 215 for (int i = 0; i < offsets.length; i++) { 216 trace.processEdge(ObjectReference.fromObject(object), base.plus(offsets[i])); 217 } 218 } 219 220 // Reference Arrays 221 public static void referenceArray(Object object, TransitiveClosure trace) { 222 Address base = Magic.objectAsAddress(object); 223 int length = ObjectModel.getArrayLength(object); 224 for (int i = 0; i < length; i++) { 225 trace.processEdge(ObjectReference.fromObject(object), base.plus(i << LOG_BYTES_IN_ADDRESS)); 226 } 227 } 228 229 // No Reference fields / Primitive Arrays 230 public static void noReferences(Object object, TransitiveClosure trace) {} 231 232 // All patterns bottom out here 233 @Inline 234 public static void pattern(int pattern, Object object, TransitiveClosure trace) { 235 Address base = Magic.objectAsAddress(object).plus(FIELD_ZERO_OFFSET); 236 if ((pattern & 1) != 0) { 237 trace.processEdge(ObjectReference.fromObject(object), base.plus(0)); 238 } 239 if ((pattern & 2) != 0) { 240 trace.processEdge(ObjectReference.fromObject(object), base.plus(1 << LOG_BYTES_IN_ADDRESS)); 241 } 242 if ((pattern & 4) != 0) { 243 trace.processEdge(ObjectReference.fromObject(object), base.plus(2 << LOG_BYTES_IN_ADDRESS)); 244 } 245 if ((pattern & 8) != 0) { 246 trace.processEdge(ObjectReference.fromObject(object), base.plus(3 << LOG_BYTES_IN_ADDRESS)); 247 } 248 if ((pattern & 16) != 0) { 249 trace.processEdge(ObjectReference.fromObject(object), base.plus(4 << LOG_BYTES_IN_ADDRESS)); 250 } 251 if ((pattern & 32) != 0) { 252 trace.processEdge(ObjectReference.fromObject(object), base.plus(5 << LOG_BYTES_IN_ADDRESS)); 253 } 254 } 255 256 /** 257 * Find the template method name for a given pattern. 258 * 259 * @param pattern The pattern to look for 260 * @return The method name that will be used. 261 */ 262 private Atom templateMethodName(int pattern) { 263 switch(pattern) { 264 case 1: return Names.scalarRNNNNN; 265 case 2: return Names.scalarNRNNNN; 266 case 3: return Names.scalarRRNNNN; 267 case 4: return Names.scalarNNRNNN; 268 case 5: return Names.scalarRNRNNN; 269 case 6: return Names.scalarNRRNNN; 270 case 7: return Names.scalarRRRNNN; 271 case 8: return Names.scalarNNNRNN; 272 case 9: return Names.scalarRNNRNN; 273 case 10: return Names.scalarNRNRNN; 274 case 11: return Names.scalarRRNRNN; 275 case 12: return Names.scalarNNRRNN; 276 case 13: return Names.scalarRNRRNN; 277 case 14: return Names.scalarNRRRNN; 278 case 15: return Names.scalarRRRRNN; 279 case 16: return Names.scalarNNNNRN; 280 case 17: return Names.scalarRNNNRN; 281 case 18: return Names.scalarNRNNRN; 282 case 19: return Names.scalarRRNNRN; 283 case 20: return Names.scalarNNRNRN; 284 case 21: return Names.scalarRNRNRN; 285 case 22: return Names.scalarNRRNRN; 286 case 23: return Names.scalarRRRNRN; 287 case 24: return Names.scalarNNNRRN; 288 case 25: return Names.scalarRNNRRN; 289 case 26: return Names.scalarNRNRRN; 290 case 27: return Names.scalarRRNRRN; 291 case 28: return Names.scalarNNRRRN; 292 case 29: return Names.scalarRNRRRN; 293 case 30: return Names.scalarNRRRRN; 294 case 31: return Names.scalarRRRRRN; 295 case 32: return Names.scalarNNNNNR; 296 case 33: return Names.scalarRNNNNR; 297 case 34: return Names.scalarNRNNNR; 298 case 35: return Names.scalarRRNNNR; 299 case 36: return Names.scalarNNRNNR; 300 case 37: return Names.scalarRNRNNR; 301 case 38: return Names.scalarNRRNNR; 302 case 39: return Names.scalarRRRNNR; 303 case 40: return Names.scalarNNNRNR; 304 case 41: return Names.scalarRNNRNR; 305 case 42: return Names.scalarNRNRNR; 306 case 43: return Names.scalarRRNRNR; 307 case 44: return Names.scalarNNRRNR; 308 case 45: return Names.scalarRNRRNR; 309 case 46: return Names.scalarNRRRNR; 310 case 47: return Names.scalarRRRRNR; 311 case 48: return Names.scalarNNNNRR; 312 case 49: return Names.scalarRNNNRR; 313 case 50: return Names.scalarNRNNRR; 314 case 51: return Names.scalarRRNNRR; 315 case 52: return Names.scalarNNRNRR; 316 case 53: return Names.scalarRNRNRR; 317 case 54: return Names.scalarNRRNRR; 318 case 55: return Names.scalarRRRNRR; 319 case 56: return Names.scalarNNNRRR; 320 case 57: return Names.scalarRNNRRR; 321 case 58: return Names.scalarNRNRRR; 322 case 59: return Names.scalarRRNRRR; 323 case 60: return Names.scalarNNRRRR; 324 case 61: return Names.scalarRNRRRR; 325 case 62: return Names.scalarNRRRRR; 326 case 63: return Names.scalarRRRRRR; 327 case NULL_PATTERN: return Names.noReferences; 328 case REFARRAY_PATTERN: return Names.referenceArray; 329 case FALLBACK_PATTERN: 330 default: return Names.scalar; 331 } 332 } 333 334 /** The generic descriptor for the specialized methods */ 335 private static final Atom specializedMethodDescriptor = Atom.findOrCreateAsciiAtom("(Ljava/lang/Object;Lorg/mmtk/plan/TransitiveClosure;)V"); 336 337 /** The atoms for the names of the specialized methods */ 338 private static final class Names { 339 static final Atom fallback = Atom.findOrCreateAsciiAtom("fallback"); 340 static final Atom referenceArray = Atom.findOrCreateAsciiAtom("referenceArray"); 341 static final Atom scalar = Atom.findOrCreateAsciiAtom("scalar"); 342 static final Atom noReferences = Atom.findOrCreateAsciiAtom("noReferences"); 343 static final Atom scalarRNNNNN = Atom.findOrCreateAsciiAtom("scalarRNNNNN"); 344 static final Atom scalarNRNNNN = Atom.findOrCreateAsciiAtom("scalarNRNNNN"); 345 static final Atom scalarRRNNNN = Atom.findOrCreateAsciiAtom("scalarRRNNNN"); 346 static final Atom scalarNNRNNN = Atom.findOrCreateAsciiAtom("scalarNNRNNN"); 347 static final Atom scalarRNRNNN = Atom.findOrCreateAsciiAtom("scalarRNRNNN"); 348 static final Atom scalarNRRNNN = Atom.findOrCreateAsciiAtom("scalarNRRNNN"); 349 static final Atom scalarRRRNNN = Atom.findOrCreateAsciiAtom("scalarRRRNNN"); 350 static final Atom scalarNNNRNN = Atom.findOrCreateAsciiAtom("scalarNNNRNN"); 351 static final Atom scalarRNNRNN = Atom.findOrCreateAsciiAtom("scalarRNNRNN"); 352 static final Atom scalarNRNRNN = Atom.findOrCreateAsciiAtom("scalarNRNRNN"); 353 static final Atom scalarRRNRNN = Atom.findOrCreateAsciiAtom("scalarRRNRNN"); 354 static final Atom scalarNNRRNN = Atom.findOrCreateAsciiAtom("scalarNNRRNN"); 355 static final Atom scalarRNRRNN = Atom.findOrCreateAsciiAtom("scalarRNRRNN"); 356 static final Atom scalarNRRRNN = Atom.findOrCreateAsciiAtom("scalarNRRRNN"); 357 static final Atom scalarRRRRNN = Atom.findOrCreateAsciiAtom("scalarRRRRNN"); 358 static final Atom scalarNNNNRN = Atom.findOrCreateAsciiAtom("scalarNNNNRN"); 359 static final Atom scalarRNNNRN = Atom.findOrCreateAsciiAtom("scalarRNNNRN"); 360 static final Atom scalarNRNNRN = Atom.findOrCreateAsciiAtom("scalarNRNNRN"); 361 static final Atom scalarRRNNRN = Atom.findOrCreateAsciiAtom("scalarRRNNRN"); 362 static final Atom scalarNNRNRN = Atom.findOrCreateAsciiAtom("scalarNNRNRN"); 363 static final Atom scalarRNRNRN = Atom.findOrCreateAsciiAtom("scalarRNRNRN"); 364 static final Atom scalarNRRNRN = Atom.findOrCreateAsciiAtom("scalarNRRNRN"); 365 static final Atom scalarRRRNRN = Atom.findOrCreateAsciiAtom("scalarRRRNRN"); 366 static final Atom scalarNNNRRN = Atom.findOrCreateAsciiAtom("scalarNNNRRN"); 367 static final Atom scalarRNNRRN = Atom.findOrCreateAsciiAtom("scalarRNNRRN"); 368 static final Atom scalarNRNRRN = Atom.findOrCreateAsciiAtom("scalarNRNRRN"); 369 static final Atom scalarRRNRRN = Atom.findOrCreateAsciiAtom("scalarRRNRRN"); 370 static final Atom scalarNNRRRN = Atom.findOrCreateAsciiAtom("scalarNNRRRN"); 371 static final Atom scalarRNRRRN = Atom.findOrCreateAsciiAtom("scalarRNRRRN"); 372 static final Atom scalarNRRRRN = Atom.findOrCreateAsciiAtom("scalarNRRRRN"); 373 static final Atom scalarRRRRRN = Atom.findOrCreateAsciiAtom("scalarRRRRRN"); 374 static final Atom scalarNNNNNR = Atom.findOrCreateAsciiAtom("scalarNNNNNR"); 375 static final Atom scalarRNNNNR = Atom.findOrCreateAsciiAtom("scalarRNNNNR"); 376 static final Atom scalarNRNNNR = Atom.findOrCreateAsciiAtom("scalarNRNNNR"); 377 static final Atom scalarRRNNNR = Atom.findOrCreateAsciiAtom("scalarRRNNNR"); 378 static final Atom scalarNNRNNR = Atom.findOrCreateAsciiAtom("scalarNNRNNR"); 379 static final Atom scalarRNRNNR = Atom.findOrCreateAsciiAtom("scalarRNRNNR"); 380 static final Atom scalarNRRNNR = Atom.findOrCreateAsciiAtom("scalarNRRNNR"); 381 static final Atom scalarRRRNNR = Atom.findOrCreateAsciiAtom("scalarRRRNNR"); 382 static final Atom scalarNNNRNR = Atom.findOrCreateAsciiAtom("scalarNNNRNR"); 383 static final Atom scalarRNNRNR = Atom.findOrCreateAsciiAtom("scalarRNNRNR"); 384 static final Atom scalarNRNRNR = Atom.findOrCreateAsciiAtom("scalarNRNRNR"); 385 static final Atom scalarRRNRNR = Atom.findOrCreateAsciiAtom("scalarRRNRNR"); 386 static final Atom scalarNNRRNR = Atom.findOrCreateAsciiAtom("scalarNNRRNR"); 387 static final Atom scalarRNRRNR = Atom.findOrCreateAsciiAtom("scalarRNRRNR"); 388 static final Atom scalarNRRRNR = Atom.findOrCreateAsciiAtom("scalarNRRRNR"); 389 static final Atom scalarRRRRNR = Atom.findOrCreateAsciiAtom("scalarRRRRNR"); 390 static final Atom scalarNNNNRR = Atom.findOrCreateAsciiAtom("scalarNNNNRR"); 391 static final Atom scalarRNNNRR = Atom.findOrCreateAsciiAtom("scalarRNNNRR"); 392 static final Atom scalarNRNNRR = Atom.findOrCreateAsciiAtom("scalarNRNNRR"); 393 static final Atom scalarRRNNRR = Atom.findOrCreateAsciiAtom("scalarRRNNRR"); 394 static final Atom scalarNNRNRR = Atom.findOrCreateAsciiAtom("scalarNNRNRR"); 395 static final Atom scalarRNRNRR = Atom.findOrCreateAsciiAtom("scalarRNRNRR"); 396 static final Atom scalarNRRNRR = Atom.findOrCreateAsciiAtom("scalarNRRNRR"); 397 static final Atom scalarRRRNRR = Atom.findOrCreateAsciiAtom("scalarRRRNRR"); 398 static final Atom scalarNNNRRR = Atom.findOrCreateAsciiAtom("scalarNNNRRR"); 399 static final Atom scalarRNNRRR = Atom.findOrCreateAsciiAtom("scalarRNNRRR"); 400 static final Atom scalarNRNRRR = Atom.findOrCreateAsciiAtom("scalarNRNRRR"); 401 static final Atom scalarRRNRRR = Atom.findOrCreateAsciiAtom("scalarRRNRRR"); 402 static final Atom scalarNNRRRR = Atom.findOrCreateAsciiAtom("scalarNNRRRR"); 403 static final Atom scalarRNRRRR = Atom.findOrCreateAsciiAtom("scalarRNRRRR"); 404 static final Atom scalarNRRRRR = Atom.findOrCreateAsciiAtom("scalarNRRRRR"); 405 static final Atom scalarRRRRRR = Atom.findOrCreateAsciiAtom("scalarRRRRRR"); 406 } 407 408 // CHECKSTYLE:OFF 409 410 public static void scalarRNNNNN(Object object, TransitiveClosure trace) { pattern( 1, object, trace); } 411 public static void scalarNRNNNN(Object object, TransitiveClosure trace) { pattern( 2, object, trace); } 412 public static void scalarRRNNNN(Object object, TransitiveClosure trace) { pattern( 3, object, trace); } 413 public static void scalarNNRNNN(Object object, TransitiveClosure trace) { pattern( 4, object, trace); } 414 public static void scalarRNRNNN(Object object, TransitiveClosure trace) { pattern( 5, object, trace); } 415 public static void scalarNRRNNN(Object object, TransitiveClosure trace) { pattern( 6, object, trace); } 416 public static void scalarRRRNNN(Object object, TransitiveClosure trace) { pattern( 7, object, trace); } 417 public static void scalarNNNRNN(Object object, TransitiveClosure trace) { pattern( 8, object, trace); } 418 public static void scalarRNNRNN(Object object, TransitiveClosure trace) { pattern( 9, object, trace); } 419 public static void scalarNRNRNN(Object object, TransitiveClosure trace) { pattern(10, object, trace); } 420 public static void scalarRRNRNN(Object object, TransitiveClosure trace) { pattern(11, object, trace); } 421 public static void scalarNNRRNN(Object object, TransitiveClosure trace) { pattern(12, object, trace); } 422 public static void scalarRNRRNN(Object object, TransitiveClosure trace) { pattern(13, object, trace); } 423 public static void scalarNRRRNN(Object object, TransitiveClosure trace) { pattern(14, object, trace); } 424 public static void scalarRRRRNN(Object object, TransitiveClosure trace) { pattern(15, object, trace); } 425 public static void scalarNNNNRN(Object object, TransitiveClosure trace) { pattern(16, object, trace); } 426 public static void scalarRNNNRN(Object object, TransitiveClosure trace) { pattern(17, object, trace); } 427 public static void scalarNRNNRN(Object object, TransitiveClosure trace) { pattern(18, object, trace); } 428 public static void scalarRRNNRN(Object object, TransitiveClosure trace) { pattern(19, object, trace); } 429 public static void scalarNNRNRN(Object object, TransitiveClosure trace) { pattern(20, object, trace); } 430 public static void scalarRNRNRN(Object object, TransitiveClosure trace) { pattern(21, object, trace); } 431 public static void scalarNRRNRN(Object object, TransitiveClosure trace) { pattern(22, object, trace); } 432 public static void scalarRRRNRN(Object object, TransitiveClosure trace) { pattern(23, object, trace); } 433 public static void scalarNNNRRN(Object object, TransitiveClosure trace) { pattern(24, object, trace); } 434 public static void scalarRNNRRN(Object object, TransitiveClosure trace) { pattern(25, object, trace); } 435 public static void scalarNRNRRN(Object object, TransitiveClosure trace) { pattern(26, object, trace); } 436 public static void scalarRRNRRN(Object object, TransitiveClosure trace) { pattern(27, object, trace); } 437 public static void scalarNNRRRN(Object object, TransitiveClosure trace) { pattern(28, object, trace); } 438 public static void scalarRNRRRN(Object object, TransitiveClosure trace) { pattern(29, object, trace); } 439 public static void scalarNRRRRN(Object object, TransitiveClosure trace) { pattern(30, object, trace); } 440 public static void scalarRRRRRN(Object object, TransitiveClosure trace) { pattern(31, object, trace); } 441 public static void scalarNNNNNR(Object object, TransitiveClosure trace) { pattern(32, object, trace); } 442 public static void scalarRNNNNR(Object object, TransitiveClosure trace) { pattern(33, object, trace); } 443 public static void scalarNRNNNR(Object object, TransitiveClosure trace) { pattern(34, object, trace); } 444 public static void scalarRRNNNR(Object object, TransitiveClosure trace) { pattern(35, object, trace); } 445 public static void scalarNNRNNR(Object object, TransitiveClosure trace) { pattern(36, object, trace); } 446 public static void scalarRNRNNR(Object object, TransitiveClosure trace) { pattern(37, object, trace); } 447 public static void scalarNRRNNR(Object object, TransitiveClosure trace) { pattern(38, object, trace); } 448 public static void scalarRRRNNR(Object object, TransitiveClosure trace) { pattern(39, object, trace); } 449 public static void scalarNNNRNR(Object object, TransitiveClosure trace) { pattern(40, object, trace); } 450 public static void scalarRNNRNR(Object object, TransitiveClosure trace) { pattern(41, object, trace); } 451 public static void scalarNRNRNR(Object object, TransitiveClosure trace) { pattern(42, object, trace); } 452 public static void scalarRRNRNR(Object object, TransitiveClosure trace) { pattern(43, object, trace); } 453 public static void scalarNNRRNR(Object object, TransitiveClosure trace) { pattern(44, object, trace); } 454 public static void scalarRNRRNR(Object object, TransitiveClosure trace) { pattern(45, object, trace); } 455 public static void scalarNRRRNR(Object object, TransitiveClosure trace) { pattern(46, object, trace); } 456 public static void scalarRRRRNR(Object object, TransitiveClosure trace) { pattern(47, object, trace); } 457 public static void scalarNNNNRR(Object object, TransitiveClosure trace) { pattern(48, object, trace); } 458 public static void scalarRNNNRR(Object object, TransitiveClosure trace) { pattern(49, object, trace); } 459 public static void scalarNRNNRR(Object object, TransitiveClosure trace) { pattern(50, object, trace); } 460 public static void scalarRRNNRR(Object object, TransitiveClosure trace) { pattern(51, object, trace); } 461 public static void scalarNNRNRR(Object object, TransitiveClosure trace) { pattern(52, object, trace); } 462 public static void scalarRNRNRR(Object object, TransitiveClosure trace) { pattern(53, object, trace); } 463 public static void scalarNRRNRR(Object object, TransitiveClosure trace) { pattern(54, object, trace); } 464 public static void scalarRRRNRR(Object object, TransitiveClosure trace) { pattern(55, object, trace); } 465 public static void scalarNNNRRR(Object object, TransitiveClosure trace) { pattern(56, object, trace); } 466 public static void scalarRNNRRR(Object object, TransitiveClosure trace) { pattern(57, object, trace); } 467 public static void scalarNRNRRR(Object object, TransitiveClosure trace) { pattern(58, object, trace); } 468 public static void scalarRRNRRR(Object object, TransitiveClosure trace) { pattern(59, object, trace); } 469 public static void scalarNNRRRR(Object object, TransitiveClosure trace) { pattern(60, object, trace); } 470 public static void scalarRNRRRR(Object object, TransitiveClosure trace) { pattern(61, object, trace); } 471 public static void scalarNRRRRR(Object object, TransitiveClosure trace) { pattern(62, object, trace); } 472 public static void scalarRRRRRR(Object object, TransitiveClosure trace) { pattern(63, object, trace); } 473 474 // CHECKSTYLE:ON 475}