1 /*
  2  * Copyright (c) 2015, 2020, 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.  Oracle designates this
  8  * particular file as subject to the "Classpath" exception as provided
  9  * by Oracle in the LICENSE file that accompanied this code.
 10  *
 11  * This code is distributed in the hope that it will be useful, but WITHOUT
 12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 14  * version 2 for more details (a copy is included in the LICENSE file that
 15  * accompanied this code).
 16  *
 17  * You should have received a copy of the GNU General Public License version
 18  * 2 along with this work; if not, write to the Free Software Foundation,
 19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 20  *
 21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 22  * or visit www.oracle.com if you need additional information or have any
 23  * questions.
 24  */
 25 package java.lang;
 26 
 27 import jdk.internal.reflect.MethodAccessor;
 28 import jdk.internal.reflect.ConstructorAccessor;
 29 import java.lang.StackWalker.Option;
 30 import java.lang.StackWalker.StackFrame;
 31 
 32 import java.lang.annotation.Native;
 33 import java.lang.reflect.Method;
 34 import java.lang.reflect.Constructor;
 35 import java.util.HashSet;
 36 import java.util.NoSuchElementException;
 37 import java.util.Objects;
 38 import java.util.Set;
 39 import java.util.Spliterator;
 40 import java.util.function.Consumer;
 41 import java.util.function.Function;
 42 import java.util.stream.Stream;
 43 import java.util.stream.StreamSupport;
 44 import sun.security.action.GetPropertyAction;
 45 
 46 import static java.lang.StackStreamFactory.WalkerState.*;
 47 
 48 /**
 49  * StackStreamFactory class provides static factory methods
 50  * to get different kinds of stack walker/traverser.
 51  *
 52  * AbstractStackWalker provides the basic stack walking support
 53  * fetching stack frames from VM in batches.
 54  *
 55  * AbstractStackWalker subclass is specialized for a specific kind of stack traversal
 56  * to avoid overhead of Stream/Lambda
 57  * 1. Support traversing Stream<StackFrame>
 58  * 2. StackWalker::getCallerClass
 59  * 3. AccessControlContext getting ProtectionDomain
 60  */
 61 final class StackStreamFactory {
 62     private StackStreamFactory() {}
 63 
 64     // Stack walk implementation classes to be excluded during stack walking
 65     // lazily add subclasses when they are loaded.
 66     private static final Set<Class<?>> stackWalkImplClasses = init();
 67 
 68     private static final int SMALL_BATCH       = 8;
 69     private static final int BATCH_SIZE        = 32;
 70     private static final int LARGE_BATCH_SIZE  = 256;
 71     private static final int MIN_BATCH_SIZE    = SMALL_BATCH;
 72 
 73     // These flags must match the values maintained in the VM
 74     @Native private static final int DEFAULT_MODE              = 0x0;
 75     @Native private static final int FILL_CLASS_REFS_ONLY      = 0x2;
 76     @Native private static final int GET_CALLER_CLASS          = 0x4;
 77     @Native private static final int SHOW_HIDDEN_FRAMES        = 0x20;  // LambdaForms are hidden by the VM
 78     @Native private static final int FILL_LIVE_STACK_FRAMES    = 0x100;
 79     /*
 80      * For Throwable to use StackWalker, set useNewThrowable to true.
 81      * Performance work and extensive testing is needed to replace the
 82      * VM built-in backtrace filled in Throwable with the StackWalker.
 83      */
 84     static final boolean isDebug =
 85             "true".equals(GetPropertyAction.privilegedGetProperty("stackwalk.debug"));
 86 
 87     static <T> StackFrameTraverser<T>
 88         makeStackTraverser(StackWalker walker, Function<? super Stream<StackFrame>, ? extends T> function)
 89     {
 90         if (walker.hasLocalsOperandsOption())
 91             return new LiveStackInfoTraverser<>(walker, function);
 92         else
 93             return new StackFrameTraverser<>(walker, function);
 94     }
 95 
 96     /**
 97      * Gets a stack stream to find caller class.
 98      */
 99     static CallerClassFinder makeCallerFinder(StackWalker walker) {
100         return new CallerClassFinder(walker);
101     }
102 
103     enum WalkerState {
104         NEW,     // the stream is new and stack walking has not started
105         OPEN,    // the stream is open when it is being traversed.
106         CLOSED;  // the stream is closed when the stack walking is done
107     }
108 
109     /**
110      * Subclass of AbstractStackWalker implements a specific stack walking logic.
111      * It needs to set up the frame buffer and stack walking mode.
112      *
113      * It initiates the VM stack walking via the callStackWalk method that serves
114      * as the anchored frame and VM will call up to AbstractStackWalker::doStackWalk.
115      *
116      * @param <R> the type of the result returned from stack walking
117      * @param <T> the type of the data gathered for each frame.
118      *            For example, StackFrameInfo for StackWalker::walk or
119      *            Class<?> for StackWalker::getCallerClass
120      */
121     static abstract class AbstractStackWalker<R, T> {
122         protected final StackWalker walker;
123         protected final Thread thread;
124         protected final int maxDepth;
125         protected final long mode;
126         protected int depth;    // traversed stack depth
127         protected FrameBuffer<? extends T> frameBuffer;
128         protected long anchor;
129 
130         // buffers to fill in stack frame information
131         protected AbstractStackWalker(StackWalker walker, int mode) {
132             this(walker, mode, Integer.MAX_VALUE);
133         }
134         protected AbstractStackWalker(StackWalker walker, int mode, int maxDepth) {
135             this.thread = Thread.currentThread();
136             this.mode = toStackWalkMode(walker, mode);
137             this.walker = walker;
138             this.maxDepth = maxDepth;
139             this.depth = 0;
140         }
141 
142         private int toStackWalkMode(StackWalker walker, int mode) {
143             int newMode = mode;
144             if (walker.hasOption(Option.SHOW_HIDDEN_FRAMES) &&
145                     (mode & FILL_CLASS_REFS_ONLY) != FILL_CLASS_REFS_ONLY)
146                 newMode |= SHOW_HIDDEN_FRAMES;
147             if (walker.hasLocalsOperandsOption())
148                 newMode |= FILL_LIVE_STACK_FRAMES;
149             return newMode;
150         }
151 
152         /**
153          * A callback method to consume the stack frames.  This method is invoked
154          * once stack walking begins (i.e. it is only invoked when walkFrames is called).
155          *
156          * Each specialized AbstractStackWalker subclass implements the consumeFrames method
157          * to control the following:
158          * 1. fetch the subsequent batches of stack frames
159          * 2. reuse or expand the allocated buffers
160          * 3. create specialized StackFrame objects
161          *
162          * @return the number of consumed frames
163          */
164          protected abstract R consumeFrames();
165 
166         /**
167          * Initialize FrameBuffer.  Subclass should implement this method to
168          * create its custom frame buffers.
169          */
170          protected abstract void initFrameBuffer();
171 
172         /**
173          * Returns the suggested next batch size.
174          *
175          * Subclass should override this method to change the batch size
176          *
177          * @param lastBatchFrameCount number of frames in the last batch; or zero
178          * @return suggested batch size
179          */
180         protected abstract int batchSize(int lastBatchFrameCount);
181 
182         /*
183          * Returns the next batch size, always >= minimum batch size (32)
184          *
185          * Subclass may override this method if the minimum batch size is different.
186          */
187         protected int getNextBatchSize() {
188             int lastBatchSize = depth == 0 ? 0 : frameBuffer.curBatchFrameCount();
189             int nextBatchSize = batchSize(lastBatchSize);
190             if (isDebug) {
191                 System.err.println("last batch size = " + lastBatchSize +
192                                    " next batch size = " + nextBatchSize);
193             }
194             return nextBatchSize >= MIN_BATCH_SIZE ? nextBatchSize : MIN_BATCH_SIZE;
195         }
196 
197         /*
198          * Checks if this stream is in the given state. Otherwise, throws IllegalStateException.
199          *
200          * VM also validates this stream if it's anchored for stack walking
201          * when stack frames are fetched for each batch.
202          */
203         final void checkState(WalkerState state) {
204             if (thread != Thread.currentThread()) {
205                 throw new IllegalStateException("Invalid thread walking this stack stream: " +
206                         Thread.currentThread().getName() + " " + thread.getName());
207             }
208             switch (state) {
209                 case NEW:
210                     if (anchor != 0) {
211                         throw new IllegalStateException("This stack stream is being reused.");
212                     }
213                     break;
214                 case OPEN:
215                     if (anchor == 0 || anchor == -1L) {
216                         throw new IllegalStateException("This stack stream is not valid for walking.");
217                     }
218                     break;
219                 case CLOSED:
220                     if (anchor != -1L) {
221                         throw new IllegalStateException("This stack stream is not closed.");
222                     }
223             }
224         }
225 
226         /*
227          * Close this stream.  This stream becomes invalid to walk.
228          */
229         private void close() {
230             this.anchor = -1L;
231         }
232 
233         /*
234          * Walks stack frames until {@link #consumeFrames} is done consuming
235          * the frames it is interested in.
236          */
237         final R walk() {
238             checkState(NEW);
239             try {
240                 // VM will need to stabilize the stack before walking.  It will invoke
241                 // the AbstractStackWalker::doStackWalk method once it fetches the first batch.
242                 // the callback will be invoked within the scope of the callStackWalk frame.
243                 return beginStackWalk();
244             } finally {
245                 close();  // done traversal; close the stream
246             }
247         }
248 
249         private boolean skipReflectionFrames() {
250             return !walker.hasOption(Option.SHOW_REFLECT_FRAMES) &&
251                        !walker.hasOption(Option.SHOW_HIDDEN_FRAMES);
252         }
253 
254         /*
255          * Returns {@code Class} object at the current frame;
256          * or {@code null} if no more frame. If advanceToNextBatch is true,
257          * it will only fetch the next batch.
258          */
259         final Class<?> peekFrame() {
260             while (frameBuffer.isActive() && depth < maxDepth) {
261                 if (frameBuffer.isEmpty()) {
262                     // fetch another batch of stack frames
263                     getNextBatch();
264                 } else {
265                     Class<?> c = frameBuffer.get();
266                     if (skipReflectionFrames() && isReflectionFrame(c)) {
267                         if (isDebug)
268                             System.err.println("  skip: frame " + frameBuffer.getIndex() + " " + c);
269 
270                         frameBuffer.next();
271                         depth++;
272                         continue;
273                     } else {
274                         return c;
275                     }
276                 }
277             }
278             return null;
279         }
280 
281         /*
282          * This method is only invoked by VM.
283          *
284          * It will invoke the consumeFrames method to start the stack walking
285          * with the first batch of stack frames.  Each specialized AbstractStackWalker
286          * subclass implements the consumeFrames method to control the following:
287          * 1. fetch the subsequent batches of stack frames
288          * 2. reuse or expand the allocated buffers
289          * 3. create specialized StackFrame objects
290          */
291         private Object doStackWalk(long anchor, int skipFrames, int batchSize,
292                                                 int bufStartIndex, int bufEndIndex) {
293             checkState(NEW);
294 
295             frameBuffer.check(skipFrames);
296 
297             if (isDebug) {
298                 System.err.format("doStackWalk: skip %d start %d end %d%n",
299                         skipFrames, bufStartIndex, bufEndIndex);
300             }
301 
302             this.anchor = anchor;  // set anchor for this bulk stack frame traversal
303             frameBuffer.setBatch(depth, bufStartIndex, bufEndIndex);
304 
305             // traverse all frames and perform the action on the stack frames, if specified
306             return consumeFrames();
307         }
308 
309         /*
310          * Get next batch of stack frames.
311          */
312         private int getNextBatch() {
313             int nextBatchSize = Math.min(maxDepth - depth, getNextBatchSize());
314             if (!frameBuffer.isActive() || nextBatchSize <= 0) {
315                 if (isDebug) {
316                     System.out.format("  more stack walk done%n");
317                 }
318                 frameBuffer.freeze();   // stack walk done
319                 return 0;
320             }
321 
322             return fetchStackFrames(nextBatchSize);
323         }
324 
325         /*
326          * This method traverses the next stack frame and returns the Class
327          * invoking that stack frame.
328          *
329          * This method can only be called during the walk method.  This is intended
330          * to be used to walk the stack frames in one single invocation and
331          * this stack stream will be invalidated once walk is done.
332          *
333          * @see #tryNextFrame
334          */
335         final Class<?> nextFrame() {
336             if (!hasNext()) {
337                 return null;
338             }
339 
340             Class<?> c = frameBuffer.next();
341             depth++;
342             return c;
343         }
344 
345         /*
346          * Returns true if there is next frame to be traversed.
347          * This skips hidden frames unless this StackWalker has
348          * {@link Option#SHOW_REFLECT_FRAMES}
349          */
350         final boolean hasNext() {
351             return peekFrame() != null;
352         }
353 
354         /**
355          * Begin stack walking - pass the allocated arrays to the VM to fill in
356          * stack frame information.
357          *
358          * VM first anchors the frame of the current thread.  A traversable stream
359          * on this thread's stack will be opened.  The VM will fetch the first batch
360          * of stack frames and call AbstractStackWalker::doStackWalk to invoke the
361          * stack walking function on each stack frame.
362          *
363          * If all fetched stack frames are traversed, AbstractStackWalker::fetchStackFrames will
364          * fetch the next batch of stack frames to continue.
365          */
366         private R beginStackWalk() {
367             // initialize buffers for VM to fill the stack frame info
368             initFrameBuffer();
369 
370             return callStackWalk(mode, 0,
371                                  frameBuffer.curBatchFrameCount(),
372                                  frameBuffer.startIndex(),
373                                  frameBuffer.frames());
374         }
375 
376         /*
377          * Fetches stack frames.
378          *
379          * @params batchSize number of elements of the frame  buffers for this batch
380          * @returns number of frames fetched in this batch
381          */
382         private int fetchStackFrames(int batchSize) {
383             int startIndex = frameBuffer.startIndex();
384             frameBuffer.resize(startIndex, batchSize);
385 
386             int endIndex = fetchStackFrames(mode, anchor, batchSize,
387                                             startIndex,
388                                             frameBuffer.frames());
389             if (isDebug) {
390                 System.out.format("  more stack walk requesting %d got %d to %d frames%n",
391                                   batchSize, frameBuffer.startIndex(), endIndex);
392             }
393             int numFrames = endIndex - startIndex;
394             if (numFrames == 0) {
395                 frameBuffer.freeze(); // done stack walking
396             } else {
397                 frameBuffer.setBatch(depth, startIndex, endIndex);
398             }
399             return numFrames;
400         }
401 
402         /**
403          * Begins stack walking.  This method anchors this frame and invokes
404          * AbstractStackWalker::doStackWalk after fetching the first batch of stack frames.
405          *
406          * @param mode        mode of stack walking
407          * @param skipframes  number of frames to be skipped before filling the frame buffer.
408          * @param batchSize   the batch size, max. number of elements to be filled in the frame buffers.
409          * @param startIndex  start index of the frame buffers to be filled.
410          * @param frames      Either a Class<?> array, if mode is {@link #FILL_CLASS_REFS_ONLY}
411          *                    or a {@link StackFrameInfo} (or derivative) array otherwise.
412          * @return            Result of AbstractStackWalker::doStackWalk
413          */
414         private native R callStackWalk(long mode, int skipframes,
415                                        int batchSize, int startIndex,
416                                        T[] frames);
417 
418         /**
419          * Fetch the next batch of stack frames.
420          *
421          * @param mode        mode of stack walking
422          * @param anchor
423          * @param batchSize   the batch size, max. number of elements to be filled in the frame buffers.
424          * @param startIndex  start index of the frame buffers to be filled.
425          * @param frames      Either a Class<?> array, if mode is {@link #FILL_CLASS_REFS_ONLY}
426          *                    or a {@link StackFrameInfo} (or derivative) array otherwise.
427          *
428          * @return the end index to the frame buffers
429          */
430         private native int fetchStackFrames(long mode, long anchor,
431                                             int batchSize, int startIndex,
432                                             T[] frames);
433     }
434 
435     /*
436      * This StackFrameTraverser supports {@link Stream} traversal.
437      *
438      * This class implements Spliterator::forEachRemaining and Spliterator::tryAdvance.
439      */
440     static class StackFrameTraverser<T> extends AbstractStackWalker<T, StackFrameInfo>
441             implements Spliterator<StackFrame>
442     {
443         static {
444             stackWalkImplClasses.add(StackFrameTraverser.class);
445         }
446         private static final int CHARACTERISTICS = Spliterator.ORDERED | Spliterator.IMMUTABLE;
447 
448         final class StackFrameBuffer extends FrameBuffer<StackFrameInfo> {
449             private StackFrameInfo[] stackFrames;
450             StackFrameBuffer(int initialBatchSize) {
451                 super(initialBatchSize);
452 
453                 this.stackFrames = new StackFrameInfo[initialBatchSize];
454                 for (int i = START_POS; i < initialBatchSize; i++) {
455                     stackFrames[i] = new StackFrameInfo(walker);
456                 }
457             }
458 
459             @Override
460             StackFrameInfo[] frames() {
461                 return stackFrames;
462             }
463 
464             @Override
465             void resize(int startIndex, int elements) {
466                 if (!isActive())
467                     throw new IllegalStateException("inactive frame buffer can't be resized");
468 
469                 assert startIndex == START_POS :
470                        "bad start index " + startIndex + " expected " + START_POS;
471 
472                 int size = startIndex+elements;
473                 if (stackFrames.length < size) {
474                     StackFrameInfo[] newFrames = new StackFrameInfo[size];
475                     // copy initial magic...
476                     System.arraycopy(stackFrames, 0, newFrames, 0, startIndex);
477                     stackFrames = newFrames;
478                 }
479                 for (int i = startIndex; i < size; i++) {
480                     stackFrames[i] = new StackFrameInfo(walker);
481                 }
482                 currentBatchSize = size;
483             }
484 
485             @Override
486             StackFrameInfo nextStackFrame() {
487                 if (isEmpty()) {
488                     throw new NoSuchElementException("origin=" + origin + " fence=" + fence);
489                 }
490 
491                 StackFrameInfo frame = stackFrames[origin];
492                 origin++;
493                 return frame;
494             }
495 
496             @Override
497             final Class<?> at(int index) {
498                 return stackFrames[index].declaringClass();
499             }
500         }
501 
502         final Function<? super Stream<StackFrame>, ? extends T> function;  // callback
503 
504         StackFrameTraverser(StackWalker walker,
505                             Function<? super Stream<StackFrame>, ? extends T> function) {
506             this(walker, function, DEFAULT_MODE);
507         }
508         StackFrameTraverser(StackWalker walker,
509                             Function<? super Stream<StackFrame>, ? extends T> function,
510                             int mode) {
511             super(walker, mode);
512             this.function = function;
513         }
514 
515         /**
516          * Returns next StackFrame object in the current batch of stack frames;
517          * or null if no more stack frame.
518          */
519         StackFrame nextStackFrame() {
520             if (!hasNext()) {
521                 return null;
522             }
523 
524             StackFrameInfo frame = frameBuffer.nextStackFrame();
525             depth++;
526             return frame;
527         }
528 
529         @Override
530         protected T consumeFrames() {
531             checkState(OPEN);
532             Stream<StackFrame> stream = StreamSupport.stream(this, false);
533             if (function != null) {
534                 return function.apply(stream);
535             } else
536                 throw new UnsupportedOperationException();
537         }
538 
539         @Override
540         protected void initFrameBuffer() {
541             this.frameBuffer = new StackFrameBuffer(getNextBatchSize());
542         }
543 
544         @Override
545         protected int batchSize(int lastBatchFrameCount) {
546             if (lastBatchFrameCount == 0) {
547                 // First batch, use estimateDepth if not exceed the large batch size
548                 // and not too small
549                 int initialBatchSize = Math.max(walker.estimateDepth(), SMALL_BATCH);
550                 return Math.min(initialBatchSize, LARGE_BATCH_SIZE);
551             } else {
552                 if (lastBatchFrameCount > BATCH_SIZE) {
553                     return lastBatchFrameCount;
554                 } else {
555                     return Math.min(lastBatchFrameCount*2, BATCH_SIZE);
556                 }
557             }
558         }
559 
560         // ------- Implementation of Spliterator
561 
562         @Override
563         public Spliterator<StackFrame> trySplit() {
564             return null;   // ordered stream and do not allow to split
565         }
566 
567         @Override
568         public long estimateSize() {
569             return maxDepth;
570         }
571 
572         @Override
573         public int characteristics() {
574             return CHARACTERISTICS;
575         }
576 
577         @Override
578         public void forEachRemaining(Consumer<? super StackFrame> action) {
579             checkState(OPEN);
580             for (int n = 0; n < maxDepth; n++) {
581                 StackFrame frame = nextStackFrame();
582                 if (frame == null) break;
583 
584                 action.accept(frame);
585             }
586         }
587 
588         @Override
589         public boolean tryAdvance(Consumer<? super StackFrame> action) {
590             checkState(OPEN);
591 
592             int index = frameBuffer.getIndex();
593             if (hasNext()) {
594                 StackFrame frame = nextStackFrame();
595                 action.accept(frame);
596                 if (isDebug) {
597                     System.err.println("tryAdvance: " + index + " " + frame);
598                 }
599                 return true;
600             }
601             if (isDebug) {
602                 System.err.println("tryAdvance: " + index + " NO element");
603             }
604             return false;
605         }
606     }
607 
608     /*
609      * CallerClassFinder is specialized to return Class<?> for each stack frame.
610      * StackFrame is not requested.
611      */
612     static final class CallerClassFinder extends AbstractStackWalker<Integer, Class<?>> {
613         static {
614             stackWalkImplClasses.add(CallerClassFinder.class);
615         }
616 
617         private Class<?> caller;
618 
619         CallerClassFinder(StackWalker walker) {
620             super(walker, FILL_CLASS_REFS_ONLY|GET_CALLER_CLASS);
621         }
622 
623         static final class ClassBuffer extends FrameBuffer<Class<?>> {
624             Class<?>[] classes;      // caller class for fast path
625             ClassBuffer(int batchSize) {
626                 super(batchSize);
627                 classes = new Class<?>[batchSize];
628             }
629 
630             @Override
631             Class<?>[] frames() { return classes;}
632 
633             @Override
634             final Class<?> at(int index) { return classes[index];}
635 
636 
637             // ------ subclass may override the following methods -------
638             /**
639              * Resizes the buffers for VM to fill in the next batch of stack frames.
640              * The next batch will start at the given startIndex with the maximum number
641              * of elements.
642              *
643              * <p> Subclass may override this method to manage the allocated buffers.
644              *
645              * @param startIndex the start index for the first frame of the next batch to fill in.
646              * @param elements the number of elements for the next batch to fill in.
647              *
648              */
649             @Override
650             void resize(int startIndex, int elements) {
651                 if (!isActive())
652                     throw new IllegalStateException("inactive frame buffer can't be resized");
653 
654                 assert startIndex == START_POS :
655                        "bad start index " + startIndex + " expected " + START_POS;
656 
657                 int size = startIndex+elements;
658                 if (classes.length < size) {
659                     // copy the elements in classes array to the newly allocated one.
660                     // classes[0] is a Thread object
661                     Class<?>[] prev = classes;
662                     classes = new Class<?>[size];
663                     System.arraycopy(prev, 0, classes, 0, startIndex);
664                 }
665                 currentBatchSize = size;
666             }
667         }
668 
669         Class<?> findCaller() {
670             walk();
671             return caller;
672         }
673 
674         @Override
675         protected Integer consumeFrames() {
676             checkState(OPEN);
677             int n = 0;
678             Class<?>[] frames = new Class<?>[2];
679             // skip the API calling this getCallerClass method
680             // 0: StackWalker::getCallerClass
681             // 1: caller-sensitive method
682             // 2: caller class
683             while (n < 2 && (caller = nextFrame()) != null) {
684                 if (isMethodHandleFrame(caller)) { continue; }
685                 if (isReflectionFrame(caller)) { continue; }
686                 frames[n++] = caller;
687             }
688             if (frames[1] == null) {
689                 throw new IllegalCallerException("no caller frame");
690             }
691             return n;
692         }
693 
694         @Override
695         protected void initFrameBuffer() {
696             this.frameBuffer = new ClassBuffer(getNextBatchSize());
697         }
698 
699         @Override
700         protected int batchSize(int lastBatchFrameCount) {
701             return MIN_BATCH_SIZE;
702         }
703 
704         @Override
705         protected int getNextBatchSize() {
706             return MIN_BATCH_SIZE;
707         }
708     }
709 
710     static final class LiveStackInfoTraverser<T> extends StackFrameTraverser<T> {
711         static {
712             stackWalkImplClasses.add(LiveStackInfoTraverser.class);
713         }
714         // VM will fill in all method info and live stack info directly in StackFrameInfo
715         final class LiveStackFrameBuffer extends FrameBuffer<LiveStackFrameInfo> {
716             private LiveStackFrameInfo[] stackFrames;
717             LiveStackFrameBuffer(int initialBatchSize) {
718                 super(initialBatchSize);
719                 this.stackFrames = new LiveStackFrameInfo[initialBatchSize];
720                 for (int i = START_POS; i < initialBatchSize; i++) {
721                     stackFrames[i] = new LiveStackFrameInfo(walker);
722                 }
723             }
724 
725             @Override
726             LiveStackFrameInfo[] frames() {
727                 return stackFrames;
728             }
729 
730             @Override
731             void resize(int startIndex, int elements) {
732                 if (!isActive()) {
733                     throw new IllegalStateException("inactive frame buffer can't be resized");
734                 }
735                 assert startIndex == START_POS :
736                        "bad start index " + startIndex + " expected " + START_POS;
737 
738                 int size = startIndex + elements;
739                 if (stackFrames.length < size) {
740                     LiveStackFrameInfo[] newFrames = new LiveStackFrameInfo[size];
741                     // copy initial magic...
742                     System.arraycopy(stackFrames, 0, newFrames, 0, startIndex);
743                     stackFrames = newFrames;
744                 }
745 
746                 for (int i = startIndex(); i < size; i++) {
747                     stackFrames[i] = new LiveStackFrameInfo(walker);
748                 }
749 
750                 currentBatchSize = size;
751             }
752 
753             @Override
754             LiveStackFrameInfo nextStackFrame() {
755                 if (isEmpty()) {
756                     throw new NoSuchElementException("origin=" + origin + " fence=" + fence);
757                 }
758 
759                 LiveStackFrameInfo frame = stackFrames[origin];
760                 origin++;
761                 return frame;
762             }
763 
764             @Override
765             final Class<?> at(int index) {
766                 return stackFrames[index].declaringClass();
767             }
768         }
769 
770         LiveStackInfoTraverser(StackWalker walker,
771                                Function<? super Stream<StackFrame>, ? extends T> function) {
772             super(walker, function, DEFAULT_MODE);
773         }
774 
775         @Override
776         protected void initFrameBuffer() {
777             this.frameBuffer = new LiveStackFrameBuffer(getNextBatchSize());
778         }
779     }
780 
781     /*
782      * Frame buffer
783      *
784      * Each specialized AbstractStackWalker subclass may subclass the FrameBuffer.
785      */
786     static abstract class FrameBuffer<F> {
787         static final int START_POS = 2;     // 0th and 1st elements are reserved
788 
789         // buffers for VM to fill stack frame info
790         int currentBatchSize;    // current batch size
791         int origin;         // index to the current traversed stack frame
792         int fence;          // index to the last frame in the current batch
793 
794         FrameBuffer(int initialBatchSize) {
795             if (initialBatchSize < MIN_BATCH_SIZE) {
796                 throw new IllegalArgumentException(initialBatchSize +
797                         " < minimum batch size: " + MIN_BATCH_SIZE);
798             }
799             this.origin = START_POS;
800             this.fence = 0;
801             this.currentBatchSize = initialBatchSize;
802         }
803 
804         /**
805          * Returns an array of frames that may be used to store frame objects
806          * when walking the stack.
807          *
808          * May be an array of {@code Class<?>} if the {@code AbstractStackWalker}
809          * mode is {@link #FILL_CLASS_REFS_ONLY}, or an array of
810          * {@link StackFrameInfo} (or derivative) array otherwise.
811          *
812          * @return An array of frames that may be used to store frame objects
813          * when walking the stack. Must not be null.
814          */
815         abstract F[] frames(); // must not return null
816 
817         /**
818          * Resizes the buffers for VM to fill in the next batch of stack frames.
819          * The next batch will start at the given startIndex with the maximum number
820          * of elements.
821          *
822          * <p> Subclass may override this method to manage the allocated buffers.
823          *
824          * @param startIndex the start index for the first frame of the next batch to fill in.
825          * @param elements the number of elements for the next batch to fill in.
826          *
827          */
828         abstract void resize(int startIndex, int elements);
829 
830         /**
831          * Return the class at the given position in the current batch.
832          * @param index the position of the frame.
833          * @return the class at the given position in the current batch.
834          */
835         abstract Class<?> at(int index);
836 
837         // ------ subclass may override the following methods -------
838 
839         /*
840          * Returns the start index for this frame buffer is refilled.
841          *
842          * This implementation reuses the allocated buffer for the next batch
843          * of stack frames.  For subclass to retain the fetched stack frames,
844          * it should override this method to return the index at which the frame
845          * should be filled in for the next batch.
846          */
847         int startIndex() {
848             return START_POS;
849         }
850 
851         /**
852          * Returns next StackFrame object in the current batch of stack frames
853          */
854         F nextStackFrame() {
855             throw new InternalError("should not reach here");
856         }
857 
858         // ------ FrameBuffer implementation ------
859 
860         final int curBatchFrameCount() {
861             return currentBatchSize-START_POS;
862         }
863 
864         /*
865          * Tests if this frame buffer is empty.  All frames are fetched.
866          */
867         final boolean isEmpty() {
868             return origin >= fence || (origin == START_POS && fence == 0);
869         }
870 
871         /*
872          * Freezes this frame buffer.  The stack stream source is done fetching.
873          */
874         final void freeze() {
875             origin = 0;
876             fence = 0;
877         }
878 
879         /*
880          * Tests if this frame buffer is active.  It is inactive when
881          * it is done for traversal.  All stack frames have been traversed.
882          */
883         final boolean isActive() {
884             return origin > 0 && (fence == 0 || origin < fence || fence == currentBatchSize);
885         }
886 
887         /**
888          * Gets the class at the current frame and move to the next frame.
889          */
890         final Class<?> next() {
891             if (isEmpty()) {
892                 throw new NoSuchElementException("origin=" + origin + " fence=" + fence);
893             }
894             Class<?> c = at(origin);
895             origin++;
896             if (isDebug) {
897                 int index = origin-1;
898                 System.out.format("  next frame at %d: %s (origin %d fence %d)%n", index,
899                         Objects.toString(c), index, fence);
900             }
901             return c;
902         }
903 
904         /**
905          * Gets the class at the current frame.
906          */
907         final Class<?> get() {
908             if (isEmpty()) {
909                 throw new NoSuchElementException("origin=" + origin + " fence=" + fence);
910             }
911             return at(origin);
912         }
913 
914         /*
915          * Returns the index of the current frame.
916          */
917         final int getIndex() {
918             return origin;
919         }
920 
921         /*
922          * Set the start and end index of a new batch of stack frames that have
923          * been filled in this frame buffer.
924          */
925         final void setBatch(int depth, int startIndex, int endIndex) {
926             if (startIndex <= 0 || endIndex <= 0)
927                 throw new IllegalArgumentException("startIndex=" + startIndex
928                         + " endIndex=" + endIndex);
929 
930             this.origin = startIndex;
931             this.fence = endIndex;
932             if (depth == 0 && fence > 0) {
933                 // filter the frames due to the stack stream implementation
934                 for (int i = START_POS; i < fence; i++) {
935                     Class<?> c = at(i);
936                     if (isDebug) System.err.format("  frame %d: %s%n", i, c);
937                     if (filterStackWalkImpl(c)) {
938                         origin++;
939                     } else {
940                         break;
941                     }
942                 }
943             }
944         }
945 
946         /*
947          * Checks if the origin is the expected start index.
948          */
949         final void check(int skipFrames) {
950             int index = skipFrames + START_POS;
951             if (origin != index) {
952                 // stack walk must continue with the previous frame depth
953                 throw new IllegalStateException("origin " + origin + " != " + index);
954             }
955         }
956     }
957 
958     private static native boolean checkStackWalkModes();
959 
960     // avoid loading other subclasses as they may not be used
961     private static Set<Class<?>> init() {
962         if (!checkStackWalkModes()) {
963             throw new InternalError("StackWalker mode values do not match with JVM");
964         }
965 
966         Set<Class<?>> classes = new HashSet<>();
967         classes.add(StackWalker.class);
968         classes.add(StackStreamFactory.class);
969         classes.add(AbstractStackWalker.class);
970         return classes;
971     }
972 
973     private static boolean filterStackWalkImpl(Class<?> c) {
974         return stackWalkImplClasses.contains(c) ||
975                 c.getName().startsWith("java.util.stream.");
976     }
977 
978     // MethodHandle frames are not hidden and CallerClassFinder has
979     // to filter them out
980     private static boolean isMethodHandleFrame(Class<?> c) {
981         return c.getName().startsWith("java.lang.invoke.");
982     }
983 
984     private static boolean isReflectionFrame(Class<?> c) {
985         // ## should filter all @Hidden frames?
986         return c == Method.class ||
987                c == Constructor.class ||
988                MethodAccessor.class.isAssignableFrom(c) ||
989                ConstructorAccessor.class.isAssignableFrom(c) ||
990                c.getName().startsWith("java.lang.invoke.LambdaForm");
991     }
992 
993 }