StackFramePredicate USER_CODE = new StackFramePredicate() {
        @Override
        public boolean test(StackTraceElement frame, StackTraceRelevance relevance) {
            return StackTraceRelevance.USER_CODE.equals(relevance);
        }
    };

    boolean test(StackTraceElement frame, StackTraceRelevance relevance);

			// and identify the goroutine by the root frame of that stack.
			// This root frame will be identical for all transitions on this
			// goroutine, because it represents its immutable start point.
			if g.Name == "" {
				stk := st.Stack
				if stk != NoStack {
					var frame StackFrame
					var ok bool
					stk.Frames(func(f StackFrame) bool {
						frame = f
						ok = true
						return true
					})

	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

	RET

// cgocallback(fn, frame unsafe.Pointer, ctxt uintptr)
// See cgocall.go for more details.
TEXT	·cgocallback(SB),NOSPLIT,$12-12
	NO_LOCAL_POINTERS

	// Skip cgocallbackg, just dropm when fn is nil, and frame is the saved g.
	// It is used to dropm while thread is exiting.
	MOVW	fn+0(FP), R1
	CMP	$0, R1
	B.NE	loadg
	// Restore the g from frame.
	MOVW	frame+4(FP), g
	B	dropm

loadg:

//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()
}

  }
}

TEST(ErrorUtilTest, StatusScopedDiagnosticHandlerWithFilter) {
  // Filtering logic is based on tensorflow::IsInternalFrameForFilename()
  // Note we are surfacing the locations that are NOT internal frames
  // so locations that fail IsInternalFrameForFilename() evaluation pass the
  // filter.

  // These locations will fail the IsInternalFrameForFilename() check so will
  // pass the filter.
  MLIRContext context;

        }
        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