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 */
013 package org.jikesrvm.mm.mminterface;
014
015 import static org.jikesrvm.classloader.RVMType.REFARRAY_OFFSET_ARRAY;
016
017 import org.jikesrvm.ArchitectureSpecific.CodeArray;
018 import org.jikesrvm.SizeConstants;
019 import org.jikesrvm.VM;
020 import org.jikesrvm.classloader.Atom;
021 import org.jikesrvm.classloader.RVMClass;
022 import org.jikesrvm.classloader.RVMMethod;
023 import org.jikesrvm.classloader.RVMType;
024 import org.jikesrvm.classloader.SpecializedMethod;
025 import org.jikesrvm.classloader.TypeReference;
026 import org.jikesrvm.compilers.common.CompiledMethod;
027 import org.jikesrvm.objectmodel.JavaHeaderConstants;
028 import org.jikesrvm.objectmodel.ObjectModel;
029 import org.jikesrvm.runtime.Magic;
030 import org.mmtk.plan.TransitiveClosure;
031 import org.vmmagic.pragma.Inline;
032 import org.vmmagic.pragma.Interruptible;
033 import org.vmmagic.pragma.NoInline;
034 import org.vmmagic.pragma.SpecializedMethodInvoke;
035 import org.vmmagic.pragma.Uninterruptible;
036 import org.vmmagic.unboxed.Address;
037 import 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
051 public final class SpecializedScanMethod extends SpecializedMethod implements SizeConstants, JavaHeaderConstants {
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 * Get the pattern index for a given type
102 */
103 @Interruptible
104 private static int getPattern(RVMType type) {
105 /* Handle array types */
106 if (type.isArrayType()) {
107 if (type.asArray().getElementType().isReferenceType()) {
108 return REFARRAY_PATTERN;
109 }
110 return NULL_PATTERN;
111 }
112
113 /* Build a bitmap if the object is compact enough and is not a reference array */
114 int[] offsets = type.getReferenceOffsets();
115
116 if (VM.VerifyAssertions) VM._assert(offsets != null);
117
118 if (offsets.length == 0) {
119 return NULL_PATTERN;
120 }
121 if ((offsets.length << LOG_BYTES_IN_ADDRESS) > SPECIALIZED_PATTERNS) {
122 return FALLBACK_PATTERN;
123 }
124
125 int base = FIELD_ZERO_OFFSET.toInt();
126 int pattern = 0;
127
128 for(int i=0; i < offsets.length; i++) {
129 int reference = (offsets[i] - base);
130 if (reference > MAX_SPECIALIZED_OFFSET) {
131 return FALLBACK_PATTERN;
132 }
133 pattern |= 1 << (reference >> LOG_BYTES_IN_ADDRESS);
134 }
135
136 if (pattern < 0 || pattern > 63) {
137 pattern = FALLBACK_PATTERN;
138 }
139
140 return pattern;
141 }
142
143 /**
144 * TODO: Lazily compile specialized methods?
145 */
146 @Override
147 @Interruptible
148 public synchronized CodeArray specializeMethod(RVMType type) {
149 /* Work out which pattern this type uses */
150 int pattern = getPattern(type);
151
152 if (VM.BuildWithBaseBootImageCompiler) {
153 /* There is no point specializing if we aren't opt compiling */
154 return null;
155 }
156
157 /* Ensure we have a compiled method cached. */
158 if (VM.VerifyAssertions) VM._assert(specializedMethods[pattern] != null);
159
160 /* Return the code entry array */
161 return specializedMethods[pattern].getEntryCodeArray();
162 }
163
164 @Override
165 public TypeReference[] getSignature() {
166 return signature;
167 }
168
169 @Override
170 public TypeReference getReturnType() {
171 return returnType;
172 }
173
174 /**
175 * This method performs the scanning of a given object.
176 * <p>
177 * This is the method that (may) be hijacked by the compiler to call the specialized method.
178 * <p>
179 * It is safe for a compiler to ignore the potential gains and just use this method
180 * directly.
181 *
182 * @param id The specialized method id
183 * @param object The object to scan
184 * @param trace The trace to scan
185 */
186 @SpecializedMethodInvoke
187 @NoInline
188 public static void invoke(int id, Object object, TransitiveClosure trace) {
189 /* By default we call a non-specialized fallback */
190 fallback(object, trace);
191 }
192
193 /** Fallback */
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 }