package abi

Import Path
	internal/abi (on go.dev)

Dependency Relation
	imports 2 packages, and imported by 3 packages


Involved Source Files

	      abi.go
	      abi_amd64.go
	      abi_test.s


Package-Level Type Names (total 2, both are exported)


	/* sort exporteds by:  |  */
	
		IntArgRegBitmap is a bitmap large enough to hold one bit per
		integer argument/return register.

		
			
				Get returns whether the i'th bit of the bitmap is set.

				nosplit because it's called in extremely sensitive contexts, like
				on the reflectcall return path.

			
				Set sets the i'th bit of the bitmap to 1.

		
			


	
		RegArgs is a struct that has space for each argument
		and return value register on the current architecture.

		Assembly code knows the layout of the first two fields
		of RegArgs.

		RegArgs also contains additional space to hold pointers
		when it may not be safe to keep them only in the integer
		register space otherwise.

		
			
				// untyped float registers

			
				Values in these slots should be precisely the bit-by-bit
				representation of how they would appear in a register.

				This means that on big endian arches, integer values should
				be in the top bits of the slot. Floats are usually just
				directly represented, but some architectures treat narrow
				width floating point values specially (e.g. they're promoted
				first, or they need to be NaN-boxed).
				// untyped integer registers

			
				Ptrs is a space that duplicates Ints but with pointer type,
				used to make pointers passed or returned  in registers
				visible to the GC by making the type unsafe.Pointer.

			
				ReturnIsPtr is a bitmap that indicates which registers
				contain or will contain pointers on the return path from
				a reflectcall. The i'th bit indicates whether the i'th
				register contains or will contain a valid Go pointer.

		
			(*RegArgs) Dump()
			
				IntRegArgAddr returns a pointer inside of r.Ints[reg] that is appropriately
				offset for an argument of size argSize.

				argSize must be non-zero, fit in a register, and a power-of-two.

				This method is a helper for dealing with the endianness of different CPU
				architectures, since sub-word-sized arguments in big endian architectures
				need to be "aligned" to the upper edge of the register to be interpreted
				by the CPU correctly.

		
			




Package-Level Functions (total 2, both are exported)


	
		FuncPCABI0 returns the entry PC of the function f, which must be a
		direct reference of a function defined as ABI0. Otherwise it is a
		compile-time error.

		Implemented as a compile intrinsic.


	
		FuncPCABIInternal returns the entry PC of the function f. If f is a
		direct reference of a function, it must be defined as ABIInternal.
		Otherwise it is a compile-time error. If f is not a direct reference
		of a defined function, it assumes that f is a func value. Otherwise
		the behavior is undefined.

		Implemented as a compile intrinsic.




Package-Level Constants (total 3, all are exported)


	
		We use SSE2 registers which support 64-bit float operations.


	
		X0 -> X14.


	
		RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11.