* table
-N chain
-I chain 1 -f foo -b bar
-I chain 2 -f foo -b baaz
-I chain 3 -f foo -b baz

* nat
-A PREROUTING -f foo -b bar
COMMIT
* table
-N chain
-A chain -f foo -b bar
-I chain 2 -f foo -b bar
-A chain -f foo -b baz

	MOVD  plist_base+0(FP), R1  // r1 points to plist
	MOVD  bpx_offset+24(FP), R2 // r2 offset to BPX vector table
	MOVD  R14, R7               // save r14
	MOVD  R15, R8               // save r15
	MOVWZ 16(R0), R9
	MOVWZ 544(R9), R9
	MOVWZ 24(R9), R9            // call vector in r9
	ADD   R2, R9                // add offset to vector table
	MOVWZ (R9), R9              // r9 points to entry point

// license that can be found in the LICENSE file.

package runtime

import (
	"internal/abi"
	_ "unsafe" // for linkname
)

// inlinedCall is the encoding of entries in the FUNCDATA_InlTree table.
type inlinedCall struct {
	funcID    abi.FuncID // type of the called function
	_         [3]byte
	nameOff   int32 // offset into pclntab for name of called function

            // referenced in the symbol table automatically, but not its `expect` counterpart, because it isn't contained in the files to
            // compile. `shouldReferenceUndiscoveredExpectSymbols` references such `expect` symbols in the symbol table so that they can
            // subsequently be stubbed.
            shouldReferenceUndiscoveredExpectSymbols = true,

However, the latest Java version may only be supported for compilation or testing, not for running Gradle.
Support is achieved using <<toolchains#toolchains,toolchains>> and applies to all tasks supporting toolchains.

See the table below for the Java version supported by a specific Gradle release:

.Java Compatibility
|===
|Java version | Support for toolchains | Support for running Gradle

| 8 | N/A | 2.0
| 9 | N/A | 4.3
| 10| N/A | 4.7

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include "../../../../../runtime/textflag.h"

TEXT asmtest(SB),DUPOK|NOSPLIT,$0
lable1:
	BFPT	1(PC)			// 00050048
	BFPT	lable1	// BFPT 2	//1ffdff4b

lable2:
	BFPF	1(PC)			// 00040048
	BFPF	lable2	// BFPF 4 	// 1ffcff4b

	// relocation in play so the assembled offset should be 0
	JMP	foo(SB)			// 00000050

	}

	// Parse the PCs out of the child's crash report.
	pcs, err := parseStackPCs(crash)
	if err != nil {
		t.Fatal(err)
	}

	// Unwind the stack using this executable's symbol table.
	got := formatStack(pcs)
	want := `redacted.go:0: runtime.gopanic
traceback_system_test.go:85: runtime_test.child7: 	panic("oops")
traceback_system_test.go:68: runtime_test.child6: 	child7() // appears in stack trace

    auto root = op->getParentOfType<ModuleOp>();
    auto func = BuildGELUDecomposition(
        rhs_add.getType().cast<RankedTensorType>(), rewriter, root.getBody());

    SymbolTable table(root);
    (void)table.renameToUnique(func, {});

    rewriter.setInsertionPointAfter(output_mul);
    auto composite_attrs = rewriter.getDictionaryAttr(
        {rewriter.getNamedAttr("approx", rewriter.getBoolAttr(false))});

}

// Error sends an Error event.
func (f *FakeWatcher) Error(errValue runtime.Object) {
	f.result <- Event{Error, errValue}
}

// Action sends an event of the requested type, for table-based testing.
func (f *FakeWatcher) Action(action EventType, obj runtime.Object) {
	f.result <- Event{action, obj}
}

// RaceFreeFakeWatcher lets you test anything that consumes a watch.Interface; threadsafe.