LVX	(rtmp)(R1), V30       \
	MOVD	$(offset+16*11), rtmp \
	LVX	(rtmp)(R1), V31

// LR and CR are saved in the caller's frame. The callee must
// make space for all other callee-save registers.
#define SAVE_ALL_REG_SIZE (SAVE_GPR_SIZE+SAVE_FPR_SIZE+SAVE_VR_SIZE)

// Stack a frame and save all callee-save registers following the
// host OS's ABI. Fortunately, this is identical for AIX, ELFv1, and

//go:build !386 && !amd64p32 && !arm && !mips && !mipsle

package main

func g() { // GC_ERROR "stack frame too large"
	xs := [3000 * 2000][33]int{}
	for _, x := range xs {
		if len(x) > 50 {

		}
	}
}

func main() { // GC_ERROR "stack frame too large"
	defer f()
	g()
}

        }
        return null;
    }

    @Nullable
    private Location tryGetLocation(StackTraceElement frame) {
        int lineNumber = frame.getLineNumber();
        if (lineNumber < 0) {
            return null;
        }

        ClassLoaderScopeOrigin.Script source = scripts.get(frame.getFileName());
        if (source == null) {
            return null;
        }

  .csect crosscall_ppc64[DS]
crosscall_ppc64:
  .llong .crosscall_ppc64, TOC[tc0], 0
  .csect .text[PR]
.crosscall_ppc64:
	// Start with standard C stack frame layout and linkage
	mflr	0
	std	0, 16(1)	// Save LR in caller's frame
	std	2, 40(1)	// Save TOC in caller's frame
	bl	saveregs
	stdu	1, -296(1)

	// Set up Go ABI constant registers
	// Must match _cgo_reginit in runtime package.
	xor 0, 0, 0

// in the object file; for example, for an ELF object, abbrev is the contents of
// the ".debug_abbrev" section.
func New(abbrev, aranges, frame, info, line, pubnames, ranges, str []byte) (*Data, error) {
	d := &Data{
		abbrev:      abbrev,
		aranges:     aranges,
		frame:       frame,
		info:        info,
		line:        line,
		pubnames:    pubnames,
		ranges:      ranges,
		str:         str,

type stack struct {
	pcs []uint64
}

func (s stack) String() string {
	var sb strings.Builder
	for _, frame := range s.pcs {
		fmt.Fprintf(&sb, "\t%#v\n", frame)
	}
	return sb.String()
}

// frame represents a single stack frame.
type frame struct {
	pc     uint64
	funcID stringID
	fileID stringID
	line   uint64

		nCallers := runtime.Callers(2, pcs[:])
		frames := runtime.CallersFrames(pcs[:nCallers])
		callers := make(stackExcerpt, 0, 10)
		more := frames != nil
		boundary := 1
		for i := 0; more && len(callers) < cap(callers); i++ {
			var frame runtime.Frame
			frame, more = frames.Next()
			fileParts := strings.Split(frame.File, "/")
			isMine := strings.HasSuffix(frame.File, "/fairqueuing/testing/eventclock/fake.go")
			if isMine {

 */
public class InternalStackTraceClassifier implements StackTraceClassifier {

    @Nullable
    @Override
    public StackTraceRelevance classify(StackTraceElement frame) {
        return isInternal(frame.getClassName()) ? StackTraceRelevance.INTERNAL : null;
    }

    private static boolean isInternal(String className) {
        // JDK calls
        return className.startsWith("java.") ||

	// Duff-adjusted address will be spilled and loaded

	*x = T{} // DUFFZERO
	runtime.GC()
	(*x)[0] = 1
	g()      // call a function with large frame, trigger a stack move
	*x = T{} // DUFFZERO again
}

//go:noinline
// a function with large frame
func g() {
	var x [1000]int
	_ = x
}

func main() {

	}

	frames := f.dwarfSourceLine(addr)
	if frames != nil {
		return frames, nil
	}

	return nil, fmt.Errorf("no line information for PC=%#x", addr)
}

// dwarfSourceLine tries to get file/line information using DWARF.
// This is for C functions that appear in the profile.
// Returns nil if there is no information available.
func (f *file) dwarfSourceLine(addr uint64) []driver.Frame {