<y:Geometry height="30.0" width="140.0" x="180.0" y="12.5"/>
          <y:Fill color="#C3D9E6" transparent="false"/>
          <y:BorderStyle color="#000000" type="line" width="1.0"/>

type gcSizes struct {
	WordSize int64 // word size in bytes - must be >= 4 (32bits)
	MaxAlign int64 // maximum alignment in bytes - must be >= 1
}

func (s *gcSizes) Alignof(T Type) (result int64) {
	defer func() {
		assert(result >= 1)
	}()

	// For arrays and structs, alignment is defined in terms
	// of alignment of the elements and fields, respectively.
	switch t := under(T).(type) {
	case *Array:

	// and is consulted to achieve NUMA aware resource alignment among this
	// and other resource controllers.
	GetTopologyHints(s state.State, pod *v1.Pod, container *v1.Container) map[string][]topologymanager.TopologyHint
	// GetPodTopologyHints implements the topologymanager.HintProvider Interface
	// and is consulted to achieve NUMA aware resource alignment among this
	// and other resource controllers.

                id 'java-platform'
            }

            dependencies {
                constraints {
                    api(project(":core")) { because "platform alignment" }
                    api(project(":lib")) { because "platform alignment" }
                }
            }

            publishing {
                publications {
                    maven(MavenPublication) {

(Zero [s] {t} ptr mem)
	&& (s > 8*128 || config.noDuffDevice) || t.Alignment()%8 != 0 =>
	(LoweredZero [t.Alignment()]
		ptr
		(ADDVconst <ptr.Type> ptr [s-moveSize(t.Alignment(), config)])
		mem)

// moves
(Move [0] _ _ mem) => mem
(Move [1] dst src mem) => (MOVBstore dst (MOVBload src mem) mem)
(Move [2] {t} dst src mem) && t.Alignment()%2 == 0 =>
	(MOVHstore dst (MOVHload src mem) mem)
(Move [2] dst src mem) =>

	// them altogether.
	ap = a.Needzero()
	bp = b.Needzero()
	if ap != bp {
		return ap
	}

	// Sort variables in descending alignment order, so we can optimally
	// pack variables into the frame.
	if a.Type().Alignment() != b.Type().Alignment() {
		return a.Type().Alignment() > b.Type().Alignment()
	}

	// Sort normal variables before open-coded-defer slots, so that the
	// latter are grouped together and near the top of the frame (to

//     struct's alignment.
//   - All other types have size WordSize.
//   - Arrays and structs are aligned per spec definition; all other
//     types are naturally aligned with a maximum alignment MaxAlign.
//
// *StdSizes implements Sizes.
type StdSizes struct {
	WordSize int64 // word size in bytes - must be >= 4 (32bits)
	MaxAlign int64 // maximum alignment in bytes - must be >= 1
}

    unsigned int B6     :  1;
    unsigned int B7     :  1;
    unsigned int B8     :  1;
    unsigned int B9     :  1;
    unsigned int B10    :  3;
    unsigned int Short2 : 16; // alignment is OK
    unsigned int Short3 : 16; // alignment is OK
};
*/
import "C"

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

package loong64

const (
	maxAlign  = 32 // max data alignment
	minAlign  = 1  // min data alignment
	funcAlign = 16
)

/* Used by ../../internal/ld/dwarf.go */
const (
	dwarfRegSP = 3
	dwarfRegLR = 1

// T is "special" because of the unnamed field, so it needs a generated equality function.
// T is an odd number of bytes in size and has alignment 1.
type T struct {
	src [8]byte
	_   byte
}

// U contains 8 copies of T, each at a different %8 alignment.
type U [8]T

//go:noinline
func f(x, y *U) bool {
	return *x == *y
}

func main() {
	var a U
	_ = f(&a, &a)