* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model.internal.asm;

import org.gradle.internal.classloader.ClassLoaderUtils;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Type;

public class AsmClassGenerator {

    private final ClassWriter visitor;
    private final String generatedTypeName;

        def newObjFile = objectFileFor(file('src/hello/asm/changed_sum.s'), "build/objs/hello/shared/helloAsm")
        assert oldObjFile.file
        assert !newObjFile.file

        when:
        asmSourceFile.renameTo(file("src/hello/asm/changed_sum.s"))
        run "mainExecutable"

        then:

#define size_t __kernel_size_t
#define sigset_t __sigset_t // rename the sigset_t here otherwise cgo will complain about "inconsistent definitions for C.sigset_t"
#define	_SYS_TYPES_H	// avoid inclusion of sys/types.h
#include <asm/ucontext.h>
#include <asm-generic/fcntl.h>
*/
import "C"

const (
	O_RDONLY    = C.O_RDONLY
	O_CLOEXEC   = C.O_CLOEXEC
	SA_RESTORER = 0 // unused
)

type Usigset C.__sigset_t

// types used in sigcontext

package org.gradle.kotlin.dsl.support.bytecode

import org.jetbrains.org.objectweb.asm.ClassVisitor
import org.jetbrains.org.objectweb.asm.ClassWriter
import org.jetbrains.org.objectweb.asm.Label
import org.jetbrains.org.objectweb.asm.MethodVisitor
import org.jetbrains.org.objectweb.asm.Opcodes
import org.jetbrains.org.objectweb.asm.Opcodes.T_BYTE
import org.jetbrains.org.objectweb.asm.Type

import kotlin.jvm.internal.CallableReference

and those with more than 3 operands usually have operands in the same order except
for the target operand, which is first in PPC64 asm and last in Go asm.

Example:

	ADD R3, R4, R5		<=>	add r5, r4, r3

2. Constant operands

In Go asm, an operand that starts with '$' indicates a constant value. If the
instruction using the constant has an immediate version of the opcode, then an

dependencies {
    api(project(":internal-instrumentation-api"))

    api(libs.asm)
    api(libs.javaPoet)
    api(libs.jsr305)

    implementation(libs.asmTree)
    implementation(libs.jacksonAnnotations)
    implementation(libs.jacksonDatabind)

    implementation(projects.stdlibJavaExtensions)
    implementation(project(":base-services"))
    implementation(project(":base-asm"))

    testCompileOnly(libs.jetbrainsAnnotations)

import static org.objectweb.asm.Opcodes.ACC_STATIC;
import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC;
import static org.objectweb.asm.Opcodes.ACC_TRANSIENT;
import static org.objectweb.asm.Opcodes.H_INVOKESPECIAL;
import static org.objectweb.asm.Opcodes.H_INVOKESTATIC;
import static org.objectweb.asm.Opcodes.H_INVOKEVIRTUAL;
import static org.objectweb.asm.Opcodes.V1_8;
import static org.objectweb.asm.Type.BOOLEAN_TYPE;

stderr '4'

# -json causes success, even with diagnostics and errors.
go vet -json -asmdecl a
stderr '"a": {'
stderr   '"asmdecl":'
stderr     '"posn": ".*asm.s:2:1",'
stderr     '"message": ".*invalid MOVW.*"'

-- a/a.go --
package a

func f(x int8)

-- a/asm.s --
TEXT ·f(SB),0,$0-1
	MOVW	x+0(FP), AX

package main

/*
#include <mach/mach_init.h>

unsigned int Mach_task_self(void) {
	return mach_task_self();
}
*/
import "C"

import "cmd/link/testdata/dynimportvar/asm"

func main() {
	c := uint32(C.Mach_task_self())
	a := asm.Mach_task_self()
	if a != c {
		println("got", a, "want", c)
		panic("FAIL")
	}

import static com.google.common.base.Preconditions.checkNotNull;

/**
 * Models a single element of a codebase that may be inspected and acted upon with
 * bytecode manipulation libraries tools like ASM.
 *
 * <p>The notion of "member" here is similar to, but broader than
 * {@link java.lang.reflect.Member}. The latter is essentially an abstraction over fields,