Add dependencies/vendor (whatsapp)

1 files changed, 5268 insertions, 0 deletions

diff --git a/vendor/modernc.org/cc/v3/check.go b/vendor/modernc.org/cc/v3/check.go
new file mode 100644
index 00000000..50887870
--- /dev/null
+++ b/vendor/modernc.org/cc/v3/check.go
@@ -0,0 +1,5268 @@
+// Copyright 2019 The CC Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cc // import "modernc.org/cc/v3"
+
+import (
+	"fmt"
+	"go/token"
+	"math"
+	"math/big"
+	"math/bits"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"modernc.org/mathutil"
+	"modernc.org/strutil"
+)
+
+const longDoublePrec = 256
+
+type mode = int
+
+var (
+	idBuiltinConstantPImpl = dict.sid("__builtin_constant_p_impl")
+	idClosure              = dict.sid("0closure") // Must be invalid indentifier.
+	idWcharT               = dict.sid("wchar_t")
+	idWinWchar             = dict.sid("WCHAR")
+
+	_ fmt.State
+)
+
+const (
+	// [2], 6.6 Constant expressions, 6
+	//
+	// An integer constant expression shall have integer type and shall
+	// only have operands that are integer constants, enumeration
+	// constants, character constants, sizeof expressions whose results are
+	// integer constants, _Alignof expressions, and floating constants that
+	// are the immediate operands of casts. Cast operators in an integer
+	// constant expression shall only convert arithmetic types to integer
+	// types, except as part of an operand to the sizeof or _Alignof
+	// operator.
+	mIntConstExpr = 1 << iota
+
+	mIntConstExprFloat   // As mIntConstExpr plus accept floating point constants.
+	mIntConstExprAnyCast // As mIntConstExpr plus accept any cast.
+)
+
+// Parameter represents a function parameter.
+type Parameter struct {
+	d   *Declarator
+	typ Type
+}
+
+// NewParameter returns a newly created parameter
+func NewParameter(d *Declarator, t Type) *Parameter {
+	return &Parameter{d, t}
+}
+
+func (p *Parameter) Declarator() *Declarator { return p.d }
+func (p *Parameter) Name() StringID          { return p.d.Name() }
+func (p *Parameter) Type() Type              { return p.typ }
+
+func (n *TranslationUnit) check(ctx *context) {
+	for n := n; n != nil; n = n.TranslationUnit {
+		n.ExternalDeclaration.check(ctx)
+	}
+	for ; n != nil; n = n.TranslationUnit {
+		n.ExternalDeclaration.checkFnBodies(ctx)
+	}
+}
+
+func (n *ExternalDeclaration) checkFnBodies(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case ExternalDeclarationFuncDef: // FunctionDefinition
+		n.FunctionDefinition.checkBody(ctx)
+	}
+}
+
+// https://gcc.gnu.org/onlinedocs/gcc/Inline.html
+//
+// If you specify both inline and extern in the function definition, then the
+// definition is used only for inlining. In no case is the function compiled on
+// its own, not even if you refer to its address explicitly. Such an address
+// becomes an external reference, as if you had only declared the function, and
+// had not defined it.
+//
+// This combination of inline and extern has almost the effect of a macro. The
+// way to use it is to put a function definition in a header file with these
+// keywords, and put another copy of the definition (lacking inline and extern)
+// in a library file. The definition in the header file causes most calls to
+// the function to be inlined. If any uses of the function remain, they refer
+// to the single copy in the library.
+func (n *Declarator) isExternInline() bool {
+	return n.IsExtern() && n.Type() != nil && n.Type().Inline()
+}
+
+// DeclarationSpecifiers Declarator DeclarationList CompoundStatement
+func (n *FunctionDefinition) checkBody(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	if n.checked {
+		return
+	}
+
+	n.checked = true
+	if n.Declarator.isExternInline() && !ctx.cfg.CheckExternInlineFnBodies {
+		return
+	}
+
+	ctx.checkFn = n
+	rd := ctx.readDelta
+	ctx.readDelta = 1
+	n.CompoundStatement.check(ctx)
+	ctx.checkFn = nil
+	for k, v := range n.ComputedGotos {
+		if _, ok := n.Labels[k]; !ok {
+			ctx.errNode(v, "label %s undefined", k)
+		}
+	}
+	for k, v := range n.Gotos {
+		if _, ok := n.Labels[k]; !ok {
+			ctx.errNode(v, "label %s undefined", k)
+		}
+	}
+	for _, n := range n.InitDeclarators {
+		d := n.Declarator
+		if d.Type().IsIncomplete() && d.Linkage != External {
+			ctx.errNode(d, "declarator has incomplete type")
+		}
+		if ctx.cfg.RejectUninitializedDeclarators && d.Linkage == None && d.Write == 0 && !d.AddressTaken && d.Read != 0 {
+			switch d.Type().Kind() {
+			case Array, Struct, Union, Invalid:
+				// nop
+			default:
+				ctx.errNode(d, "%s may be used uninitialized in this function", d.Name())
+			}
+		}
+	}
+	for _, n := range n.CompositeLiterals {
+		switch t := n.Operand.Type(); t.Kind() {
+		case Invalid:
+			ctx.errNode(n, "composite literal has invalid type")
+		default:
+			if t.IsIncomplete() {
+				ctx.errNode(n, "composite literal has incomplete type")
+			}
+		}
+	}
+	ctx.readDelta = rd
+}
+
+func (n *ExternalDeclaration) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case ExternalDeclarationFuncDef: // FunctionDefinition
+		n.FunctionDefinition.checkDeclarator(ctx)
+	case ExternalDeclarationDecl: // Declaration
+		n.Declaration.check(ctx, true)
+	case ExternalDeclarationAsm: // AsmFunctionDefinition
+		n.AsmFunctionDefinition.check(ctx)
+	case ExternalDeclarationAsmStmt: // AsmStatement
+		n.AsmStatement.check(ctx)
+	case ExternalDeclarationEmpty: // ';'
+		// nop
+	case ExternalDeclarationPragma: // PragmaSTDC
+		n.PragmaSTDC.check(ctx)
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *PragmaSTDC) check(ctx *context) {
+	// nop
+}
+
+func (n *AsmFunctionDefinition) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	typ, inline, noret := n.DeclarationSpecifiers.check(ctx, false)
+	typ.setFnSpecs(inline, noret)
+	n.Declarator.check(ctx, n.DeclarationSpecifiers, typ, true)
+	n.AsmStatement.check(ctx)
+}
+
+func (n *AsmStatement) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	n.Asm.check(ctx)
+	n.AttributeSpecifierList.check(ctx, nil)
+}
+
+func (n *Declaration) check(ctx *context, tld bool) {
+	if n == nil {
+		return
+	}
+
+	typ, _, _ := n.DeclarationSpecifiers.check(ctx, false)
+	n.InitDeclaratorList.check(ctx, n.DeclarationSpecifiers, typ, tld)
+}
+
+func (n *InitDeclaratorList) check(ctx *context, td typeDescriptor, typ Type, tld bool) {
+	for ; n != nil; n = n.InitDeclaratorList {
+		n.AttributeSpecifierList.check(ctx, typ.baseP())
+		n.InitDeclarator.check(ctx, td, typ, tld)
+	}
+}
+
+func (n *InitDeclarator) check(ctx *context, td typeDescriptor, typ Type, tld bool) {
+	if n == nil {
+		return
+	}
+
+	if f := ctx.checkFn; f != nil {
+		f.InitDeclarators = append(f.InitDeclarators, n)
+	}
+	if attr := n.AttributeSpecifierList.check(ctx, typ.baseP()); len(attr) != 0 {
+		typ = &attributedType{typ, attr}
+	}
+	switch n.Case {
+	case InitDeclaratorDecl: // Declarator AttributeSpecifierList
+		n.Declarator.check(ctx, td, typ, tld)
+	case InitDeclaratorInit: // Declarator AttributeSpecifierList '=' Initializer
+		typ := n.Declarator.check(ctx, td, typ, tld)
+		n.Declarator.hasInitializer = true
+		n.Declarator.Write++
+		n.Initializer.check(ctx, &n.Initializer.list, typ, n.Declarator.StorageClass, nil, 0, nil, nil, false)
+		n.Initializer.setConstZero()
+		n.initializer = &InitializerValue{typ: typ, initializer: n.Initializer}
+		if ctx.cfg.TrackAssignments {
+			setLHS(map[*Declarator]struct{}{n.Declarator: {}}, n.Initializer)
+		}
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *Initializer) setConstZero() {
+	switch n.Case {
+	case InitializerExpr: // AssignmentExpression
+		if op := n.AssignmentExpression.Operand; op != nil {
+			n.isConst = op.IsConst()
+			n.isZero = op.IsZero()
+		}
+	case InitializerInitList: // '{' InitializerList ',' '}'
+		li := n.InitializerList
+		li.setConstZero()
+		n.isConst = li.IsConst()
+		n.isZero = li.IsZero()
+	default:
+		panic(todo("%v:", n.Position()))
+	}
+}
+
+func (n *InitializerList) setConstZero() {
+	if n == nil {
+		return
+	}
+
+	n0 := n
+	n0.isConst = true
+	n0.isZero = true
+	for ; n != nil; n = n.InitializerList {
+		in := n.Initializer
+		in.setConstZero()
+		n0.isConst = n0.isConst && in.isConst
+		n0.isZero = n0.isZero && in.isZero
+	}
+}
+
+// [0], 6.7.8 Initialization
+func (n *Initializer) check(ctx *context, list *[]*Initializer, t Type, sc StorageClass, fld Field, off uintptr, il *InitializerList, designatorList *DesignatorList, inList bool) *InitializerList {
+	// trc("==== %v: case %v, t %v, off %v, designatorList != nil %v, inList %v", n.Position(), n.Case, t.Alias(), off, designatorList != nil, inList)
+	// if fld != nil {
+	// 	trc("\tfld %q", fld.Name())
+	// }
+
+	// 3 - The type of the entity to be initialized shall be an array of
+	// unknown size or an object type that is not a variable length array
+	// type.
+	if t.Kind() == Array && t.IsVLA() {
+		ctx.errNode(n, "cannot initialize a variable length array: %v", t)
+		if il != nil {
+			return il.InitializerList
+		}
+
+		return nil
+	}
+
+	defer func(d int) { ctx.readDelta = d }(ctx.readDelta)
+
+	ctx.readDelta = 1
+	n.typ = t
+	single := n.single()
+	var op Operand
+	if single != nil {
+		op = single.AssignmentExpression.check(ctx, false)
+		single.typ = t
+		single.Field = fld
+		single.Offset = off
+	}
+
+	// 11: The initializer for a scalar shall be a single expression, optionally
+	// enclosed in braces. The initial value of the object is that of the
+	// expression (after conversion); the same type constraints and conversions as
+	// for simple assignment apply, taking the type of the scalar to be the
+	// unqualified version of its declared type.
+	if t.IsScalarType() && single != nil {
+		if designatorList != nil {
+			panic(todo("", n.Position()))
+		}
+
+		//TODO check compatible
+		*list = append(*list, single)
+		switch {
+		case t.Kind() == op.Type().Kind():
+			single.AssignmentExpression.InitializerOperand = op
+		default:
+			single.AssignmentExpression.InitializerOperand = op.convertTo(ctx, n, t)
+		}
+		if il != nil {
+			return il.InitializerList
+		}
+
+		return nil
+	}
+
+	// 12: The rest of this subclause deals with initializers for objects that have
+	// aggregate or union type.
+
+	k := t.Kind()
+
+	// 13: The initializer for a structure or union object that has automatic
+	// storage duration shall be either an initializer list as described below, or
+	// a single expression that has compatible structure or union type. In the
+	// latter case, the initial value of the object, including unnamed members, is
+	// that of the expression.
+	if n.Case == InitializerExpr && sc == Automatic && (k == Struct || k == Union || k == Vector) && t.IsCompatible(op.Type()) {
+		if designatorList != nil {
+			panic(todo("", n.Position()))
+		}
+
+		*list = append(*list, single)
+		if il != nil {
+			return il.InitializerList
+		}
+
+		return nil
+	}
+
+	if k == Array && single != nil {
+		et := t.Elem()
+		switch {
+		case isCharType(et):
+			// 14: An array of character type may be initialized by a character string
+			// literal, optionally enclosed in braces. Successive characters of the
+			// character string literal (including the terminating null character if there
+			// is room or if the array is of unknown size) initialize the elements of the
+			// array.
+			if x, ok := op.Value().(StringValue); ok {
+				if designatorList != nil {
+					panic(todo("", n.Position()))
+				}
+
+				*list = append(*list, single)
+				str := StringID(x).String()
+				if t.IsIncomplete() {
+					t.setLen(uintptr(len(str)) + 1)
+				}
+				if il != nil {
+					return il.InitializerList
+				}
+
+				return nil
+			}
+		case isWCharType(et):
+			// 15: An array with element type compatible with wchar_t may be initialized by
+			// a wide string literal, optionally enclosed in braces. Successive wide
+			// characters of the wide string literal (including the terminating null wide
+			// character if there is room or if the array is of unknown size) initialize
+			// the elements of the array.
+			if x, ok := op.Value().(WideStringValue); ok {
+				if designatorList != nil {
+					panic(todo("", n.Position()))
+				}
+
+				*list = append(*list, single)
+				str := []rune(StringID(x).String())
+				if t.IsIncomplete() {
+					t.setLen(uintptr(len(str)) + 1)
+				}
+				if il != nil {
+					panic(todo(""))
+				}
+
+				return nil
+			}
+		}
+	}
+
+	// 16: Otherwise, the initializer for an object that has aggregate or union
+	// type shall be a brace-enclosed list of initializers for the elements or
+	// named members.
+	if n.Case == InitializerExpr {
+		if il != nil {
+			switch t.Kind() {
+			case Array:
+				return il.checkArray(ctx, list, t, sc, off, designatorList, inList)
+			case Struct:
+				return il.checkStruct(ctx, list, t, sc, off, designatorList, inList)
+			case Union:
+				return il.checkUnion(ctx, list, t, sc, off, designatorList, inList)
+			case Vector:
+				return il.InitializerList //TODO
+			default:
+				panic(todo("", n.Position(), t, t.Kind()))
+			}
+		}
+
+		var l *InitializerList
+		Inspect(n.AssignmentExpression, func(m Node, b bool) bool {
+			if x, ok := m.(*PostfixExpression); ok && x.Case == PostfixExpressionComplit {
+				if !b {
+					return true
+				}
+
+				if l == nil {
+					l = x.InitializerList
+					return true
+				}
+
+				l = nil
+				return false
+			}
+			return true
+		})
+		if l != nil {
+			l.check(ctx, list, t, sc, off, designatorList, inList)
+			return nil
+		}
+
+		ctx.errNode(n, "initializer for an object that has aggregate or union type shall be a brace-enclosed list of initializers for the elements or named members: %v", t)
+		return nil
+	}
+
+	n.InitializerList.check(ctx, list, t, sc, off, designatorList, inList)
+	if il != nil {
+		return il.InitializerList
+	}
+
+	return nil
+}
+
+func (n *InitializerList) checkArray(ctx *context, list *[]*Initializer, t Type, sc StorageClass, off uintptr, designatorList *DesignatorList, inList bool) *InitializerList {
+	elem := t.Elem()
+	esz := elem.Size()
+	length := t.Len()
+	var i, maxI uintptr
+	nestedDesignator := designatorList != nil
+	retOnDesignator := false
+loop:
+	for n != nil {
+		switch {
+		case retOnDesignator && n.Designation != nil:
+			return n
+		case designatorList == nil && !inList && n.Designation != nil:
+			designatorList = n.Designation.DesignatorList
+			fallthrough
+		case designatorList != nil:
+			d := designatorList.Designator
+			designatorList = designatorList.DesignatorList
+			switch d.Case {
+			case DesignatorIndex: // '[' ConstantExpression ']'
+				switch x := d.ConstantExpression.check(ctx, ctx.mode|mIntConstExpr, false).Value().(type) {
+				case Int64Value:
+					i = uintptr(x)
+				case Uint64Value:
+					i = uintptr(x)
+				default:
+					panic(todo("%v: %T", n.Position(), x))
+				}
+				if !inList && i > maxI {
+					maxI = i
+				}
+			case DesignatorField: // '.' IDENTIFIER
+				panic(todo("", n.Position(), d.Position()))
+			case DesignatorField2: // IDENTIFIER ':'
+				panic(todo("", n.Position(), d.Position()))
+			default:
+				panic(todo(""))
+			}
+
+			n = n.Initializer.check(ctx, list, elem, sc, nil, off+i*esz, n, designatorList, designatorList != nil)
+			designatorList = nil
+			if nestedDesignator {
+				retOnDesignator = true
+			}
+			i++
+		default:
+			if !t.IsIncomplete() && i >= length {
+				break loop
+			}
+
+			if i > maxI {
+				maxI = i
+			}
+			n = n.Initializer.check(ctx, list, elem, sc, nil, off+i*esz, n, nil, inList)
+			i++
+		}
+	}
+	if t.IsIncomplete() {
+		t.setLen(maxI + 1)
+	}
+	return n
+}
+
+func (n *InitializerList) checkStruct(ctx *context, list *[]*Initializer, t Type, sc StorageClass, off uintptr, designatorList *DesignatorList, inList bool) *InitializerList {
+	// trc("==== (A) %v: t %v, off %v, dl %v, inList %v", n.Position(), t, off, designatorList != nil, inList)
+	// defer trc("==== (Z) %v: t %v, off %v, dl %v, inList %v", n.Position(), t, off, designatorList != nil, inList)
+	t = t.underlyingType()
+	// trc("%v: %v, off %v", n.Position(), t, off) //TODO-
+	nf := t.NumField()
+	i := []int{0}
+	var f Field
+	nestedDesignator := designatorList != nil
+	retOnDesignator := false
+	for n != nil {
+		switch {
+		case retOnDesignator && n.Designation != nil:
+			return n
+		case designatorList == nil && !inList && n.Designation != nil:
+			designatorList = n.Designation.DesignatorList
+			fallthrough
+		case designatorList != nil:
+			d := designatorList.Designator
+			designatorList = designatorList.DesignatorList
+			var nm StringID
+			switch d.Case {
+			case DesignatorIndex: // '[' ConstantExpression ']'
+				panic(todo("", n.Position(), d.Position()))
+			case DesignatorField: // '.' IDENTIFIER
+				nm = d.Token2.Value
+			case DesignatorField2: // IDENTIFIER ':'
+				nm = d.Token.Value
+			default:
+				panic(todo(""))
+			}
+
+			f, xa, ok := t.FieldByName2(nm)
+			if !ok {
+				panic(todo("%v: t %v %q", d.Position(), t, nm))
+			}
+
+			t0 := t
+			switch {
+			case len(xa) != 1:
+				var f2 Field
+				var off2 uintptr
+				for len(xa) != 1 {
+					f2 = t.FieldByIndex(xa[:1])
+					off2 += f2.Offset()
+					t = f2.Type()
+					xa = xa[1:]
+				}
+				n = n.Initializer.check(ctx, list, t, sc, f, off+off2, n, designatorList, designatorList != nil)
+				if t.Kind() == Union {
+					t = t0
+				}
+			default:
+				n = n.Initializer.check(ctx, list, f.Type(), sc, f, off+f.Offset(), n, designatorList, designatorList != nil)
+			}
+			designatorList = nil
+			if nestedDesignator {
+				retOnDesignator = true
+			}
+			i[0] = xa[0] + 1
+		default:
+			// [0], 6.7.8 Initialization
+			//
+			// 9 - Except where explicitly stated otherwise, for the
+			// purposes of this subclause unnamed members of objects of
+			// structure and union type do not participate in
+			// initialization.  Unnamed members of structure objects have
+			// indeterminate value even after initialization.
+			for ; ; i[0]++ {
+				if i[0] >= nf {
+					return n
+				}
+
+				f = t.FieldByIndex(i)
+				if f.Name() != 0 || !f.Type().IsBitFieldType() {
+					n = n.Initializer.check(ctx, list, f.Type(), sc, f, off+f.Offset(), n, nil, inList)
+					i[0]++
+					break
+				}
+			}
+		}
+	}
+	return n
+}
+
+func spos(n Node) string {
+	p := n.Position()
+	p.Filename = filepath.Base(p.Filename)
+	return p.String()
+}
+
+func (n *InitializerList) checkUnion(ctx *context, list *[]*Initializer, t Type, sc StorageClass, off uintptr, designatorList *DesignatorList, inList bool) *InitializerList {
+	// trc("==== %v: t %v, off %v, dl %v, inList %v", n.Position(), t, off, designatorList != nil, inList)
+	t = t.underlyingType()
+	// trc("%v: %v, off %v", n.Position(), t, off) //TODO-
+	nf := t.NumField()
+	i := []int{0}
+	for pass := 0; n != nil; pass++ {
+		switch {
+		case designatorList == nil && !inList && n.Designation != nil:
+			designatorList = n.Designation.DesignatorList
+			fallthrough
+		case designatorList != nil:
+			d := designatorList.Designator
+			designatorList = designatorList.DesignatorList
+			var nm StringID
+			switch d.Case {
+			case DesignatorIndex: // '[' ConstantExpression ']'
+				panic(todo("", n.Position(), d.Position()))
+			case DesignatorField: // '.' IDENTIFIER
+				nm = d.Token2.Value
+			case DesignatorField2: // IDENTIFIER ':'
+				nm = d.Token.Value
+			default:
+				panic(todo(""))
+			}
+
+			f, xa, ok := t.FieldByName2(nm)
+			if !ok {
+				panic(todo("", d.Position()))
+			}
+
+			if !inList && pass == 0 {
+				n.Initializer.field0 = f
+			}
+			switch {
+			case len(xa) != 1:
+				var f2 Field
+				var off2 uintptr
+				for len(xa) != 1 {
+					f2 = t.FieldByIndex(xa[:1])
+					off2 += f2.Offset()
+					t = f2.Type()
+					xa = xa[1:]
+				}
+				next := n.Initializer.check(ctx, list, t, sc, f, off+off2+f.Offset(), n, designatorList, designatorList != nil)
+				if designatorList != nil && designatorList.DesignatorList != nil {
+					panic(todo("", n.Position(), d.Position()))
+				}
+
+				return next
+			default:
+				next := n.Initializer.check(ctx, list, f.Type(), sc, f, off+f.Offset(), n, designatorList, designatorList != nil)
+				if designatorList != nil && designatorList.DesignatorList != nil {
+					panic(todo("", n.Position(), d.Position()))
+				}
+
+				return next
+			}
+		default:
+			// [0], 6.7.8 Initialization
+			//
+			// 9 - Except where explicitly stated otherwise, for the
+			// purposes of this subclause unnamed members of objects of
+			// structure and union type do not participate in
+			// initialization.  Unnamed members of structure objects have
+			// indeterminate value even after initialization.
+			for ; ; i[0]++ {
+				if i[0] >= nf {
+					panic(todo(""))
+				}
+
+				f := t.FieldByIndex(i)
+				if f.Name() != 0 || !f.Type().IsBitFieldType() {
+					next := n.Initializer.check(ctx, list, f.Type(), sc, f, off+f.Offset(), n, nil, inList)
+					return next
+				}
+			}
+			panic(todo("", n.Position()))
+		}
+	}
+	return nil
+}
+
+// Accept a single initializer, optionally enclosed in braces, but nested
+// braces. Implements eg. [0]6.7.8.11.
+//
+//	42	// ok
+//	{42}	// ok
+//	{{42}}	// not ok
+func (n *Initializer) single() *Initializer {
+	switch n.Case {
+	case InitializerExpr: // AssignmentExpression
+		return n
+	case InitializerInitList: // '{' InitializerList ',' '}'
+		if n.InitializerList == nil { //
+			return nil
+		}
+
+		if n.InitializerList.InitializerList == nil {
+			if in := n.InitializerList.Initializer; in.Case == InitializerExpr {
+				return in
+			}
+		}
+	}
+	return nil
+}
+
+// [0], 6.7.8 Initialization
+func (n *InitializerList) check(ctx *context, list *[]*Initializer, t Type, sc StorageClass, off uintptr, designatorList *DesignatorList, inList bool) {
+	switch t.Kind() {
+	case Array, Vector:
+		if n == nil { // {}
+			if t.IsIncomplete() {
+				t.setLen(0)
+			}
+			return
+		}
+
+		n.checkArray(ctx, list, t, sc, off, designatorList, inList)
+	case Struct:
+		if n == nil { // {}
+			return
+		}
+
+		n.checkStruct(ctx, list, t, sc, off, designatorList, inList)
+	case Union:
+		if n == nil { // {}
+			return
+		}
+
+		n.checkUnion(ctx, list, t, sc, off, designatorList, inList)
+	default:
+		if n == nil || t == nil || t.Kind() == Invalid {
+			return
+		}
+
+		n.Initializer.check(ctx, list, t, sc, nil, off, nil, designatorList, inList)
+	}
+}
+
+func setLHS(lhs map[*Declarator]struct{}, rhs Node) {
+	inCall := 0
+	Inspect(rhs, func(n Node, enter bool) bool {
+		switch x := n.(type) {
+		case *PostfixExpression:
+			switch x.Case {
+			case PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
+				switch {
+				case enter:
+					inCall++
+					if d := x.Declarator(); d != nil {
+						for v := range lhs {
+							d.setLHS(v)
+						}
+					}
+				default:
+					inCall--
+				}
+			}
+		case *PrimaryExpression:
+			if inCall != 0 || !enter {
+				break
+			}
+
+			if d := x.Declarator(); d != nil {
+				for v := range lhs {
+					d.setLHS(v)
+				}
+			}
+		}
+		return true
+	})
+}
+
+func (n *AssignmentExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	if n.Operand != nil {
+		return n.Operand
+	}
+
+	if ctx.cfg.TrackAssignments && n.AssignmentExpression != nil {
+		defer func() {
+			lhs := map[*Declarator]struct{}{}
+			Inspect(n.UnaryExpression, func(n Node, enter bool) bool {
+				if !enter {
+					return true
+				}
+
+				if x, ok := n.(*PrimaryExpression); ok {
+					lhs[x.Declarator()] = struct{}{}
+				}
+				return true
+			})
+			setLHS(lhs, n.AssignmentExpression)
+		}()
+	}
+
+	//TODO check for "modifiable lvalue" in left operand
+	n.Operand = noOperand
+	switch n.Case {
+	case AssignmentExpressionCond: // ConditionalExpression
+		n.Operand = n.ConditionalExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.ConditionalExpression.IsSideEffectsFree
+	case AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Declarator(); d != nil {
+			d.Read -= ctx.readDelta
+		}
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.Write++
+			if l.Type().Kind() == Array && !d.IsParameter && l.Type().String() != "va_list" {
+				ctx.errNode(n.UnaryExpression, "assignment to expression with array type")
+				break
+			}
+		}
+
+		if !l.IsLValue() {
+			//TODO ctx.errNode(n.UnaryExpression, "expected lvalue")
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		_ = r //TODO check assignability
+		n.Operand = l.(*lvalue).Operand
+	case AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.SubjectOfAsgnOp = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		if !l.IsLValue() {
+			//TODO panic(n.Position().String()) // report error
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		//TODO check assignability
+		if l.Type().IsArithmeticType() {
+			op, _ := usualArithmeticConversions(ctx, n, l, r, true)
+			n.promote = op.Type()
+		}
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: l.Type()}
+	case AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.SubjectOfAsgnOp = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		if !l.IsLValue() {
+			//TODO panic(n.Position().String()) // report error
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		//TODO check assignability
+		if l.Type().IsArithmeticType() {
+			op, _ := usualArithmeticConversions(ctx, n, l, r, true)
+			n.promote = op.Type()
+		}
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: l.Type()}
+	case AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.SubjectOfAsgnOp = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		if !l.IsLValue() {
+			//TODO panic(n.Position().String()) // report error
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		//TODO check assignability
+		if l.Type().IsArithmeticType() {
+			op, _ := usualArithmeticConversions(ctx, n, l, r, true)
+			n.promote = op.Type()
+		}
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: l.Type()}
+	case AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.SubjectOfAsgnOp = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		if !l.IsLValue() {
+			//TODO panic(n.Position().String()) // report error
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		//TODO check assignability
+		n.promote = n.UnaryExpression.Operand.Type()
+		if l.Type().IsArithmeticType() {
+			op, _ := usualArithmeticConversions(ctx, n, l, r, true)
+			n.promote = op.Type()
+		}
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: l.Type()}
+	case AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.SubjectOfAsgnOp = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		if !l.IsLValue() {
+			//TODO panic(n.Position().String()) // report error
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		//TODO check assignability
+		n.promote = n.UnaryExpression.Operand.Type()
+		if l.Type().IsArithmeticType() {
+			op, _ := usualArithmeticConversions(ctx, n, l, r, true)
+			n.promote = op.Type()
+		}
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: l.Type()}
+	case AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.SubjectOfAsgnOp = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		if !l.IsLValue() {
+			//TODO panic(n.Position().String()) // report error
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		//TODO check assignability
+		if !l.Type().IsIntegerType() || !r.Type().IsIntegerType() {
+			//TODO report error
+			break
+		}
+
+		n.promote = r.integerPromotion(ctx, n).Type()
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: l.Type()}).integerPromotion(ctx, n)
+	case AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.SubjectOfAsgnOp = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		if !l.IsLValue() {
+			//TODO panic(n.Position().String()) // report error
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		//TODO check assignability
+		if !l.Type().IsIntegerType() || !r.Type().IsIntegerType() {
+			//TODO report error
+			break
+		}
+
+		n.promote = r.integerPromotion(ctx, n).Type()
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: l.Type()}).integerPromotion(ctx, n)
+	case AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.SubjectOfAsgnOp = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		if !l.IsLValue() {
+			//TODO panic(n.Position().String()) // report error
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		//TODO check assignability
+		if !l.Type().IsIntegerType() || !r.Type().IsIntegerType() {
+			//TODO report error
+			break
+		}
+
+		op, _ := usualArithmeticConversions(ctx, n, l, r, true)
+		n.promote = op.Type()
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: l.Type()}
+	case AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.SubjectOfAsgnOp = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		if !l.IsLValue() {
+			//TODO panic(n.Position().String()) // report error
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		//TODO check assignability
+		if !l.Type().IsIntegerType() || !r.Type().IsIntegerType() {
+			//TODO report error
+			break
+		}
+
+		op, _ := usualArithmeticConversions(ctx, n, l, r, true)
+		n.promote = op.Type()
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: l.Type()}
+	case AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
+		l := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := n.UnaryExpression.Operand.Declarator(); d != nil {
+			d.SubjectOfAsgnOp = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		if !l.IsLValue() {
+			//TODO panic(n.Position().String()) // report error
+			break
+		}
+
+		r := n.AssignmentExpression.check(ctx, isAsmArg)
+		//TODO check assignability
+		if !l.Type().IsIntegerType() || !r.Type().IsIntegerType() {
+			//TODO report error
+			break
+		}
+
+		op, _ := usualArithmeticConversions(ctx, n, l, r, true)
+		n.promote = op.Type()
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: l.Type()}
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *UnaryExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case UnaryExpressionPostfix: // PostfixExpression
+		n.Operand = n.PostfixExpression.check(ctx, false, isAsmArg)
+		n.IsSideEffectsFree = n.PostfixExpression.IsSideEffectsFree
+	case UnaryExpressionInc: // "++" UnaryExpression
+		op := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := op.Declarator(); d != nil {
+			d.SubjectOfIncDec = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: op.Type()}
+	case UnaryExpressionDec: // "--" UnaryExpression
+		op := n.UnaryExpression.check(ctx, isAsmArg)
+		if d := op.Declarator(); d != nil {
+			d.SubjectOfIncDec = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: op.Type()}
+	case UnaryExpressionAddrof: // '&' CastExpression
+		ctx.not(n, mIntConstExpr)
+		op := n.CastExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.CastExpression.IsSideEffectsFree
+		if op.Type().IsBitFieldType() {
+			//TODO report error
+			break
+		}
+
+		d := n.CastExpression.Declarator()
+		if d != nil {
+			setAddressTaken(n, d, "'&' CastExpression")
+			if d.td.register() {
+				//TODO report error
+			}
+		}
+
+		// [0], 6.5.3.2
+		//
+		// The operand of the unary & operator shall be either a
+		// function designator, the result of a [] or unary * operator,
+		// or an lvalue that designates an object that is not a
+		// bit-field and is not declared with the register
+		// storage-class specifier.
+		//TODO
+		if x, ok := op.(*funcDesignator); ok {
+			n.Operand = x
+			break
+		}
+
+		n.Operand = op
+	case UnaryExpressionDeref: // '*' CastExpression
+		ctx.not(n, mIntConstExpr)
+		op := n.CastExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.CastExpression.IsSideEffectsFree
+		if x, ok := op.(*funcDesignator); ok {
+			n.Operand = x
+			break
+		}
+
+		if op.Type().Kind() == Function {
+			n.Operand = op
+			break
+		}
+
+		if op.Type().Decay().Kind() != Ptr {
+			//TODO report error
+			break
+		}
+
+		n.Operand = &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: op.Type().Elem()}}
+	case UnaryExpressionPlus: // '+' CastExpression
+		op := n.CastExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.CastExpression.IsSideEffectsFree
+		if !op.Type().IsArithmeticType() {
+			//TODO report error
+			break
+		}
+
+		if op.Type().IsIntegerType() {
+			op = op.integerPromotion(ctx, n)
+		}
+		n.Operand = op
+	case UnaryExpressionMinus: // '-' CastExpression
+		op := n.CastExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.CastExpression.IsSideEffectsFree
+		if op.Type().Kind() == Vector {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: op.Type()}
+			break
+		}
+
+		if !op.Type().IsArithmeticType() {
+			//TODO report error
+			break
+		}
+
+		if op.Type().IsIntegerType() {
+			op = op.integerPromotion(ctx, n)
+		}
+		if v := op.Value(); v != nil {
+			op = (&operand{abi: &ctx.cfg.ABI, typ: op.Type(), value: v.neg()}).normalize(ctx, n)
+		}
+		n.Operand = op
+	case UnaryExpressionCpl: // '~' CastExpression
+		op := n.CastExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.CastExpression.IsSideEffectsFree
+		if op.Type().Kind() == Vector {
+			if !op.Type().Elem().IsIntegerType() {
+				ctx.errNode(n, "operand must be integer")
+			}
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: op.Type()}
+			break
+		}
+
+		if op.Type().IsComplexType() {
+			n.Operand = op
+			break
+		}
+
+		if !op.Type().IsIntegerType() {
+			ctx.errNode(n, "operand must be integer")
+			break
+		}
+
+		op = op.integerPromotion(ctx, n)
+		if v := op.Value(); v != nil {
+			op = (&operand{abi: &ctx.cfg.ABI, typ: op.Type(), value: v.cpl()}).normalize(ctx, n)
+		}
+		n.Operand = op
+	case UnaryExpressionNot: // '!' CastExpression
+		op := n.CastExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.CastExpression.IsSideEffectsFree
+		op2 := &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Int)}
+		switch {
+		case op.IsZero():
+			op2.value = Int64Value(1)
+		case op.IsNonZero():
+			op2.value = Int64Value(0)
+		}
+		n.Operand = op2
+	case UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression
+		n.IsSideEffectsFree = true
+		rd := ctx.readDelta
+		// [0]6.5.3.4, 2: If the type of the operand is a variable length array type,
+		// the operand is evaluated; otherwise, the operand is not evaluated and the
+		// result is an integer constant.
+		switch op := n.UnaryExpression.Operand; {
+		case op != nil && op.Type() != nil && op.Type().IsVLA():
+			ctx.readDelta = 1
+		default:
+			ctx.readDelta = 0
+		}
+		ctx.push(ctx.mode &^ mIntConstExpr)
+		op := n.UnaryExpression.check(ctx, isAsmArg)
+		ctx.pop()
+		ctx.readDelta = rd
+		if op.Type().IsIncomplete() {
+			break
+		}
+
+		sz := op.Type().Size()
+		if d := n.UnaryExpression.Declarator(); d != nil && d.IsParameter {
+			sz = op.Type().Decay().Size()
+		}
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(ULongLong), value: Uint64Value(sz)}).convertTo(ctx, n, sizeT(ctx, n.lexicalScope, n.Token))
+	case UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')'
+		n.IsSideEffectsFree = true
+		rd := ctx.readDelta
+		ctx.readDelta = 0
+		ctx.push(ctx.mode)
+		if ctx.mode&mIntConstExpr != 0 {
+			ctx.mode |= mIntConstExprAnyCast
+		}
+		t := n.TypeName.check(ctx, false, false, nil)
+		ctx.pop()
+		ctx.readDelta = rd
+		if t.IsIncomplete() {
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(ULongLong), value: Uint64Value(t.Size())}).convertTo(ctx, n, sizeT(ctx, n.lexicalScope, n.Token))
+	case UnaryExpressionLabelAddr: // "&&" IDENTIFIER
+		abi := &ctx.cfg.ABI
+		n.Operand = &operand{abi: abi, typ: abi.Ptr(n, abi.Type(Void))}
+		n.IsSideEffectsFree = true
+		ctx.not(n, mIntConstExpr)
+		f := ctx.checkFn
+		if f == nil {
+			//TODO report error
+			break
+		}
+
+		if f.ComputedGotos == nil {
+			f.ComputedGotos = map[StringID]*UnaryExpression{}
+		}
+		f.ComputedGotos[n.Token2.Value] = n
+	case UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression
+		n.IsSideEffectsFree = true
+		ctx.push(ctx.mode &^ mIntConstExpr)
+		op := n.UnaryExpression.check(ctx, isAsmArg)
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(ULongLong), value: Uint64Value(op.Type().Align())}).convertTo(ctx, n, sizeT(ctx, n.lexicalScope, n.Token))
+		ctx.pop()
+	case UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')'
+		n.IsSideEffectsFree = true
+		ctx.push(ctx.mode)
+		if ctx.mode&mIntConstExpr != 0 {
+			ctx.mode |= mIntConstExprAnyCast
+		}
+		t := n.TypeName.check(ctx, false, false, nil)
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(ULongLong), value: Uint64Value(t.Align())}).convertTo(ctx, n, sizeT(ctx, n.lexicalScope, n.Token))
+		ctx.pop()
+	case UnaryExpressionImag: // "__imag__" UnaryExpression
+		ctx.not(n, mIntConstExpr)
+		n.UnaryExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.UnaryExpression.IsSideEffectsFree
+		n.Operand = complexPart(ctx, n.UnaryExpression.Operand)
+	case UnaryExpressionReal: // "__real__" UnaryExpression
+		ctx.not(n, mIntConstExpr)
+		n.UnaryExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.UnaryExpression.IsSideEffectsFree
+		n.Operand = complexPart(ctx, n.UnaryExpression.Operand)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func complexPart(ctx *context, op Operand) Operand {
+	var k Kind
+	switch op.Type().Kind() {
+	case ComplexChar:
+		k = Char
+	case ComplexDouble:
+		k = Double
+	case ComplexFloat:
+		k = Float
+	case ComplexInt:
+		k = Int
+	case ComplexLong:
+		k = Long
+	case ComplexLongDouble:
+		k = LongDouble
+	case ComplexLongLong:
+		k = LongLong
+	case ComplexShort:
+		k = Short
+	case ComplexUInt:
+		k = UInt
+	case ComplexULong:
+		k = ULong
+	case ComplexULongLong:
+		k = ULongLong
+	case ComplexUShort:
+		k = UShort
+	default:
+		//TODO report err
+		return noOperand
+	}
+
+	abi := &ctx.cfg.ABI
+	typ := abi.Type(k)
+	return &operand{abi: abi, typ: typ}
+}
+
+func sizeT(ctx *context, s Scope, tok Token) Type {
+	if t := ctx.sizeT; t != nil {
+		return t
+	}
+
+	t := ctx.stddef(idSizeT, s, tok)
+	if t.Kind() != Invalid {
+		ctx.sizeT = t
+	}
+	return t
+}
+
+func (n *CastExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case CastExpressionUnary: // UnaryExpression
+		n.Operand = n.UnaryExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.UnaryExpression.IsSideEffectsFree
+	case CastExpressionCast: // '(' TypeName ')' CastExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *UnaryExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case UnaryExpressionPostfix: // PostfixExpression
+		n.Operand = n.PostfixExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.PostfixExpression.IsSideEffectsFree
+	case UnaryExpressionInc: // "++" UnaryExpression
+		panic(n.Position().String())
+	case UnaryExpressionDec: // "--" UnaryExpression
+		panic(n.Position().String())
+	case UnaryExpressionAddrof: // '&' CastExpression
+		panic(n.Position().String())
+	case UnaryExpressionDeref: // '*' CastExpression
+		n.Operand = n.CastExpression.check(ctx, false)
+		n.IsSideEffectsFree = n.CastExpression.IsSideEffectsFree
+	case UnaryExpressionPlus: // '+' CastExpression
+		panic(n.Position().String())
+	case UnaryExpressionMinus: // '-' CastExpression
+		panic(n.Position().String())
+	case UnaryExpressionCpl: // '~' CastExpression
+		panic(n.Position().String())
+	case UnaryExpressionNot: // '!' CastExpression
+		panic(n.Position().String())
+	case UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression
+		panic(n.Position().String())
+	case UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')'
+		panic(n.Position().String())
+	case UnaryExpressionLabelAddr: // "&&" IDENTIFIER
+		panic(n.Position().String())
+	case UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression
+		panic(n.Position().String())
+	case UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')'
+		panic(n.Position().String())
+	case UnaryExpressionImag: // "__imag__" UnaryExpression
+		n.Operand = n.UnaryExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.UnaryExpression.IsSideEffectsFree
+	case UnaryExpressionReal: // "__real__" UnaryExpression
+		n.Operand = n.UnaryExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.UnaryExpression.IsSideEffectsFree
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *PostfixExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case PostfixExpressionPrimary: // PrimaryExpression
+		n.Operand = n.PrimaryExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.PrimaryExpression.IsSideEffectsFree
+	case PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
+		pe := n.PostfixExpression.check(ctx, false, false)
+		if d := n.PostfixExpression.Declarator(); d != nil && d.Type().Kind() != Ptr {
+			setAddressTaken(n, d, "PostfixExpression '[' Expression ']'")
+			d.Read += ctx.readDelta
+		}
+		e := n.Expression.check(ctx, false)
+		n.IsSideEffectsFree = n.PostfixExpression.IsSideEffectsFree && n.Expression.IsSideEffectsFree
+		t := pe.Type().Decay()
+		if t.Kind() == Invalid {
+			break
+		}
+
+		if t.Kind() == Ptr {
+			if t := e.Type(); t.Kind() != Invalid && !t.IsIntegerType() {
+				ctx.errNode(n.Expression, "index must be integer type, have %v", e.Type())
+				break
+			}
+
+			n.Operand = n.indexAddr(ctx, &n.Token, pe, e)
+			break
+		}
+
+		if pe.Type().Kind() == Vector {
+			if t := e.Type(); t.Kind() != Invalid && !t.IsIntegerType() {
+				ctx.errNode(n.Expression, "index must be integer type, have %v", e.Type())
+				break
+			}
+
+			n.Operand = n.index(ctx, pe, e)
+			break
+		}
+
+		t = e.Type().Decay()
+		if t.Kind() == Invalid {
+			break
+		}
+
+		if t.Kind() == Ptr {
+			if t := pe.Type(); t.Kind() != Invalid && !t.IsIntegerType() {
+				ctx.errNode(n.Expression, "index must be integer type, have %v", pe.Type())
+				break
+			}
+
+			n.Operand = n.indexAddr(ctx, &n.Token, e, pe)
+			break
+		}
+
+		ctx.errNode(n, "invalid index expression %v[%v]", pe.Type(), e.Type())
+	case PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
+		panic(n.Position().String())
+	case PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
+		op := n.PostfixExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.PostfixExpression.IsSideEffectsFree
+		if d := n.PostfixExpression.Declarator(); d != nil {
+			setAddressTaken(n, d, "PostfixExpression '.' IDENTIFIER")
+			d.Read += ctx.readDelta
+		}
+		st := op.Type().Elem()
+		if k := st.Kind(); k == Invalid || k != Struct && k != Union {
+			//TODO report error
+			break
+		}
+
+		f, ok := st.FieldByName(n.Token2.Value)
+		if !ok {
+			ctx.errNode(&n.Token2, "unknown or ambiguous field: %s", n.Token2.Value)
+			break
+		}
+
+		n.Field = f
+		ft := f.Type()
+		if f.IsBitField() {
+			//TODO report error
+			break
+		}
+
+		ot := ctx.cfg.ABI.Ptr(n, ft)
+		switch {
+		case op.IsConst():
+			switch x := op.Value().(type) {
+			case Uint64Value:
+				n.Operand = &operand{abi: &ctx.cfg.ABI, typ: ot, value: x + Uint64Value(f.Offset())}
+				return n.Operand
+			case nil:
+				// nop
+			default:
+				//TODO panic(todo(" %v: %T", n.Position(), x))
+			}
+
+			fallthrough
+		default:
+			n.Operand = &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ot, offset: op.Offset() + f.Offset()}, declarator: op.Declarator()}
+		}
+	case PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
+		op := n.PostfixExpression.check(ctx, false, false)
+		n.IsSideEffectsFree = n.PostfixExpression.IsSideEffectsFree
+		if d := n.PostfixExpression.Declarator(); d != nil {
+			d.Read += ctx.readDelta
+		}
+		t := op.Type()
+		if k := t.Decay().Kind(); k == Invalid || k != Ptr {
+			//TODO report error
+			break
+		}
+
+		st := t.Elem()
+		if k := st.Kind(); k == Invalid || k != Struct && k != Union {
+			//TODO report error
+			break
+		}
+
+		f, ok := st.FieldByName(n.Token2.Value)
+		if !ok {
+			//TODO report error
+			break
+		}
+
+		n.Field = f
+		ft := f.Type()
+		if f.IsBitField() {
+			//TODO report error
+			break
+		}
+
+		ot := ctx.cfg.ABI.Ptr(n, ft)
+		switch {
+		case op.IsConst():
+			switch x := op.Value().(type) {
+			case Uint64Value:
+				n.Operand = &operand{abi: &ctx.cfg.ABI, typ: ot, value: x + Uint64Value(f.Offset())}
+				return n.Operand
+			case nil:
+				// nop
+			default:
+				panic(todo(" %T", x))
+			}
+
+			fallthrough
+		default:
+			n.Operand = &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ot, offset: op.Offset() + f.Offset()}, declarator: op.Declarator()}
+		}
+	case PostfixExpressionInc: // PostfixExpression "++"
+		panic(n.Position().String())
+	case PostfixExpressionDec: // PostfixExpression "--"
+		panic(n.Position().String())
+	case PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
+		//TODO IsSideEffectsFree
+		if f := ctx.checkFn; f != nil {
+			f.CompositeLiterals = append(f.CompositeLiterals, n)
+		}
+		t := n.TypeName.check(ctx, false, false, nil)
+		var v *InitializerValue
+		if n.InitializerList != nil {
+			n.InitializerList.isConst = true
+			n.InitializerList.check(ctx, &n.InitializerList.list, t, Automatic, 0, nil, false)
+			n.InitializerList.setConstZero()
+			v = &InitializerValue{typ: ctx.cfg.ABI.Ptr(n, t), initializer: n.InitializerList}
+		}
+		n.Operand = &lvalue{Operand: (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Ptr(n, t), value: v}).normalize(ctx, n)}
+	case PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *PostfixExpression) indexAddr(ctx *context, nd Node, pe, e Operand) Operand {
+	var x uintptr
+	hasx := false
+	switch v := e.Value().(type) {
+	case Int64Value:
+		x = uintptr(v)
+		hasx = true
+	case Uint64Value:
+		x = uintptr(v)
+		hasx = true
+	}
+	off := x * pe.Type().Elem().Size()
+	switch y := pe.Value().(type) {
+	case StringValue, WideStringValue:
+		if hasx {
+			return &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Ptr(n, pe.Type().Elem()), value: pe.Value(), offset: off}}
+		}
+	case Uint64Value:
+		if hasx {
+			return &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Ptr(n, pe.Type().Elem()), value: y + Uint64Value(off)}}
+		}
+	}
+
+	if d := pe.Declarator(); d != nil && hasx {
+		r := &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Ptr(n, pe.Type().Elem()), offset: pe.Offset() + off}, declarator: d}
+		return r
+	}
+
+	return &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Ptr(n, pe.Type().Elem())}}
+}
+
+func (n *PrimaryExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case PrimaryExpressionIdent: // IDENTIFIER
+		n.IsSideEffectsFree = true
+		n.check(ctx, false, false)
+		if d := n.Operand.Declarator(); d != nil {
+			switch d.Type().Kind() {
+			case Function:
+				// nop //TODO ?
+			default:
+				setAddressTaken(n, d, "&IDENTIFIER")
+				n.Operand = &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Ptr(n, d.Type())}, declarator: d}
+			}
+			return n.Operand
+		}
+		if ctx.cfg.RejectLateBinding && !ctx.cfg.ignoreUndefinedIdentifiers {
+			ctx.errNode(n, "front-end: undefined: %s", n.Token.Value)
+			return noOperand
+		}
+
+		//TODO
+	case PrimaryExpressionInt: // INTCONST
+		panic(n.Position().String())
+	case PrimaryExpressionFloat: // FLOATCONST
+		panic(n.Position().String())
+	case PrimaryExpressionEnum: // ENUMCONST
+		panic(n.Position().String())
+	case PrimaryExpressionChar: // CHARCONST
+		panic(n.Position().String())
+	case PrimaryExpressionLChar: // LONGCHARCONST
+		panic(n.Position().String())
+	case PrimaryExpressionString: // STRINGLITERAL
+		panic(n.Position().String())
+	case PrimaryExpressionLString: // LONGSTRINGLITERAL
+		panic(n.Position().String())
+	case PrimaryExpressionExpr: // '(' Expression ')'
+		n.Operand = n.Expression.addrOf(ctx)
+		n.IsSideEffectsFree = n.Expression.IsSideEffectsFree
+	case PrimaryExpressionStmt: // '(' CompoundStatement ')'
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *Expression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case ExpressionAssign: // AssignmentExpression
+		n.Operand = n.AssignmentExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.AssignmentExpression.IsSideEffectsFree
+	case ExpressionComma: // Expression ',' AssignmentExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *AssignmentExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case AssignmentExpressionCond: // ConditionalExpression
+		n.Operand = n.ConditionalExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.ConditionalExpression.IsSideEffectsFree
+	case AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
+		panic(n.Position().String())
+	case AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
+		panic(n.Position().String())
+	case AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
+		panic(n.Position().String())
+	case AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
+		panic(n.Position().String())
+	case AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
+		panic(n.Position().String())
+	case AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
+		panic(n.Position().String())
+	case AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression
+		panic(n.Position().String())
+	case AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
+		panic(n.Position().String())
+	case AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
+		panic(n.Position().String())
+	case AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
+		panic(n.Position().String())
+	case AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *ConditionalExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case ConditionalExpressionLOr: // LogicalOrExpression
+		n.Operand = n.LogicalOrExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.LogicalOrExpression.IsSideEffectsFree
+	case ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *LogicalOrExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case LogicalOrExpressionLAnd: // LogicalAndExpression
+		n.Operand = n.LogicalAndExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.LogicalAndExpression.IsSideEffectsFree
+	case LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *LogicalAndExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case LogicalAndExpressionOr: // InclusiveOrExpression
+		n.Operand = n.InclusiveOrExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.InclusiveOrExpression.IsSideEffectsFree
+	case LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *InclusiveOrExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case InclusiveOrExpressionXor: // ExclusiveOrExpression
+		n.Operand = n.ExclusiveOrExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.ExclusiveOrExpression.IsSideEffectsFree
+	case InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *ExclusiveOrExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case ExclusiveOrExpressionAnd: // AndExpression
+		n.Operand = n.AndExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.AndExpression.IsSideEffectsFree
+	case ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *AndExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case AndExpressionEq: // EqualityExpression
+		n.Operand = n.EqualityExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.EqualityExpression.IsSideEffectsFree
+	case AndExpressionAnd: // AndExpression '&' EqualityExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *EqualityExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case EqualityExpressionRel: // RelationalExpression
+		n.Operand = n.RelationalExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.RelationalExpression.IsSideEffectsFree
+	case EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
+		panic(n.Position().String())
+	case EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *RelationalExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case RelationalExpressionShift: // ShiftExpression
+		n.Operand = n.ShiftExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.ShiftExpression.IsSideEffectsFree
+	case RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
+		panic(n.Position().String())
+	case RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
+		panic(n.Position().String())
+	case RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
+		panic(n.Position().String())
+	case RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *ShiftExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case ShiftExpressionAdd: // AdditiveExpression
+		n.Operand = n.AdditiveExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.AdditiveExpression.IsSideEffectsFree
+	case ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
+		panic(n.Position().String())
+	case ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *AdditiveExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case AdditiveExpressionMul: // MultiplicativeExpression
+		n.Operand = n.MultiplicativeExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.MultiplicativeExpression.IsSideEffectsFree
+	case AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
+		panic(n.Position().String())
+	case AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *MultiplicativeExpression) addrOf(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case MultiplicativeExpressionCast: // CastExpression
+		n.Operand = n.CastExpression.addrOf(ctx)
+		n.IsSideEffectsFree = n.CastExpression.IsSideEffectsFree
+	case MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression
+		panic(n.Position().String())
+	case MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression
+		panic(n.Position().String())
+	case MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
+		panic(n.Position().String())
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *TypeName) check(ctx *context, inUnion, isPacked bool, list *[]*TypeSpecifier) Type {
+	if n == nil {
+		return noType
+	}
+
+	n.typ = n.SpecifierQualifierList.check(ctx, inUnion, isPacked, list)
+	if n.AbstractDeclarator != nil {
+		n.typ = n.AbstractDeclarator.check(ctx, n.typ)
+	}
+	for list := n.SpecifierQualifierList; list != nil; list = list.SpecifierQualifierList {
+		if expr, ok := list.AttributeSpecifier.Has(idVectorSize, idVectorSize2); ok {
+			n.vectorize(ctx, expr)
+			break
+		}
+	}
+	return n.typ
+}
+
+func (n *TypeName) vectorize(ctx *context, expr *ExpressionList) {
+	dst := &n.typ
+	elem := n.typ
+	switch n.typ.Kind() {
+	case Function:
+		dst = &n.typ.(*functionType).result
+		elem = n.typ.Result()
+	}
+
+	sz := expr.vectorSize(ctx)
+	if sz == 0 {
+		sz = elem.Size()
+	}
+	if sz%elem.Size() != 0 {
+		ctx.errNode(expr, "vector size must be a multiple of the base size")
+	}
+	b := n.typ.base()
+	b.size = sz
+	b.kind = byte(Vector)
+	*dst = &vectorType{
+		typeBase: b,
+		elem:     elem,
+		length:   sz / elem.Size(),
+	}
+}
+
+func (n *AbstractDeclarator) check(ctx *context, typ Type) Type {
+	if n == nil {
+		return typ
+	}
+
+	n.typ = noType //TODO-
+	switch n.Case {
+	case AbstractDeclaratorPtr: // Pointer
+		n.typ = n.Pointer.check(ctx, typ)
+	case AbstractDeclaratorDecl: // Pointer DirectAbstractDeclarator
+		typ = n.Pointer.check(ctx, typ)
+		n.typ = n.DirectAbstractDeclarator.check(ctx, typ)
+	default:
+		panic(todo(""))
+	}
+	return n.typ
+}
+
+func (n *DirectAbstractDeclarator) check(ctx *context, typ Type) Type {
+	if n == nil {
+		return typ
+	}
+
+	switch n.Case {
+	case DirectAbstractDeclaratorDecl: // '(' AbstractDeclarator ')'
+		if n.AbstractDeclarator == nil {
+			// [0], 6.7.6, 128)
+			//
+			// As indicated by the syntax, empty parentheses in a
+			// type name are interpreted as ‘‘function with no
+			// parameter specification’’, rather than redundant
+			// parentheses around the omitted identifier.
+			panic(todo("")) //TODO
+		}
+
+		return n.AbstractDeclarator.check(ctx, typ)
+	case DirectAbstractDeclaratorArr: // DirectAbstractDeclarator '[' TypeQualifiers AssignmentExpression ']'
+		return n.DirectAbstractDeclarator.check(ctx, checkArray(ctx, &n.Token, typ, n.AssignmentExpression, true, false))
+	case DirectAbstractDeclaratorStaticArr: // DirectAbstractDeclarator '[' "static" TypeQualifiers AssignmentExpression ']'
+		return n.DirectAbstractDeclarator.check(ctx, checkArray(ctx, &n.Token, typ, n.AssignmentExpression, false, false))
+	case DirectAbstractDeclaratorArrStatic: // DirectAbstractDeclarator '[' TypeQualifiers "static" AssignmentExpression ']'
+		return n.DirectAbstractDeclarator.check(ctx, checkArray(ctx, &n.Token, typ, n.AssignmentExpression, false, false))
+	case DirectAbstractDeclaratorArrStar: // DirectAbstractDeclarator '[' '*' ']'
+		return n.DirectAbstractDeclarator.check(ctx, checkArray(ctx, &n.Token, typ, nil, true, true))
+	case DirectAbstractDeclaratorFunc: // DirectAbstractDeclarator '(' ParameterTypeList ')'
+		ft := &functionType{typeBase: typeBase{kind: byte(Function)}, result: typ}
+		n.ParameterTypeList.check(ctx, ft)
+		return n.DirectAbstractDeclarator.check(ctx, ft)
+	}
+
+	panic(internalErrorf("%v: %v", n.Position(), n.Case))
+}
+
+func (n *ParameterTypeList) check(ctx *context, ft *functionType) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case ParameterTypeListList: // ParameterList
+		n.ParameterList.check(ctx, ft)
+	case ParameterTypeListVar: // ParameterList ',' "..."
+		ft.variadic = true
+		n.ParameterList.check(ctx, ft)
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *ParameterList) check(ctx *context, ft *functionType) {
+	for ; n != nil; n = n.ParameterList {
+		p := n.ParameterDeclaration.check(ctx, ft)
+		ft.params = append(ft.params, p)
+	}
+}
+
+func (n *ParameterDeclaration) check(ctx *context, ft *functionType) *Parameter {
+	if n == nil {
+		return nil
+	}
+
+	switch n.Case {
+	case ParameterDeclarationDecl: // DeclarationSpecifiers Declarator AttributeSpecifierList
+		typ, _, _ := n.DeclarationSpecifiers.check(ctx, false)
+		n.Declarator.IsParameter = true
+		if n.typ = n.Declarator.check(ctx, n.DeclarationSpecifiers, typ, false); n.typ.Kind() == Void {
+			panic(n.Position().String())
+		}
+		if n.AttributeSpecifierList != nil {
+			//TODO panic(n.Position().String())
+		}
+		n.AttributeSpecifierList.check(ctx, n.typ.baseP())
+		return &Parameter{d: n.Declarator, typ: n.typ}
+	case ParameterDeclarationAbstract: // DeclarationSpecifiers AbstractDeclarator
+		n.typ, _, _ = n.DeclarationSpecifiers.check(ctx, false)
+		if n.AbstractDeclarator != nil {
+			n.typ = n.AbstractDeclarator.check(ctx, n.typ)
+		}
+		return &Parameter{typ: n.typ}
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *Pointer) check(ctx *context, typ Type) (t Type) {
+	if n == nil || typ == nil {
+		return typ
+	}
+
+	switch n.Case {
+	case PointerTypeQual: // '*' TypeQualifiers
+		n.TypeQualifiers.check(ctx, &n.typeQualifiers)
+	case PointerPtr: // '*' TypeQualifiers Pointer
+		n.TypeQualifiers.check(ctx, &n.typeQualifiers)
+		typ = n.Pointer.check(ctx, typ)
+	case PointerBlock: // '^' TypeQualifiers
+		n.TypeQualifiers.check(ctx, &n.typeQualifiers)
+	default:
+		panic(todo(""))
+	}
+	r := ctx.cfg.ABI.Ptr(n, typ).(*pointerType)
+	if n.typeQualifiers != nil {
+		r.typeQualifiers = n.typeQualifiers.check(ctx, (*DeclarationSpecifiers)(nil), false)
+	}
+	return r
+}
+
+func (n *TypeQualifiers) check(ctx *context, typ **typeBase) {
+	for ; n != nil; n = n.TypeQualifiers {
+		switch n.Case {
+		case TypeQualifiersTypeQual: // TypeQualifier
+			if *typ == nil {
+				*typ = &typeBase{}
+			}
+			n.TypeQualifier.check(ctx, *typ)
+		case TypeQualifiersAttribute: // AttributeSpecifier
+			if *typ == nil {
+				*typ = &typeBase{}
+			}
+			n.AttributeSpecifier.check(ctx, *typ)
+		default:
+			panic(todo(""))
+		}
+	}
+}
+
+func (n *TypeQualifier) check(ctx *context, typ *typeBase) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case TypeQualifierConst: // "const"
+		typ.flags |= fConst
+	case TypeQualifierRestrict: // "restrict"
+		typ.flags |= fRestrict
+	case TypeQualifierVolatile: // "volatile"
+		typ.flags |= fVolatile
+	case TypeQualifierAtomic: // "_Atomic"
+		typ.flags |= fAtomic
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *SpecifierQualifierList) check(ctx *context, inUnion, isPacked bool, list *[]*TypeSpecifier) Type {
+	n0 := n
+	typ := &typeBase{}
+	for ; n != nil; n = n.SpecifierQualifierList {
+		switch n.Case {
+		case SpecifierQualifierListTypeSpec: // TypeSpecifier SpecifierQualifierList
+			n.TypeSpecifier.check(ctx, typ, inUnion)
+			if list != nil && n.TypeSpecifier.Case != TypeSpecifierAtomic {
+				*list = append(*list, n.TypeSpecifier)
+			}
+		case SpecifierQualifierListTypeQual: // TypeQualifier SpecifierQualifierList
+			n.TypeQualifier.check(ctx, typ)
+		case SpecifierQualifierListAlignSpec: // AlignmentSpecifier SpecifierQualifierList
+			n.AlignmentSpecifier.check(ctx)
+		case SpecifierQualifierListAttribute: // AttributeSpecifier SpecifierQualifierList
+			n.AttributeSpecifier.check(ctx, typ)
+		default:
+			panic(todo(""))
+		}
+	}
+	return typ.check(ctx, n0, true)
+}
+
+func (n *TypeSpecifier) check(ctx *context, typ *typeBase, inUnion bool) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case
+		TypeSpecifierVoid,       // "void"
+		TypeSpecifierChar,       // "char"
+		TypeSpecifierShort,      // "short"
+		TypeSpecifierInt,        // "int"
+		TypeSpecifierInt8,       // "__int8"
+		TypeSpecifierInt16,      // "__int16"
+		TypeSpecifierInt32,      // "__int32"
+		TypeSpecifierInt64,      // "__int64"
+		TypeSpecifierInt128,     // "__int128"
+		TypeSpecifierLong,       // "long"
+		TypeSpecifierFloat,      // "float"
+		TypeSpecifierFloat16,    // "__fp16"
+		TypeSpecifierDecimal32,  // "_Decimal32"
+		TypeSpecifierDecimal64,  // "_Decimal64"
+		TypeSpecifierDecimal128, // "_Decimal128"
+		TypeSpecifierFloat32,    // "_Float32"
+		TypeSpecifierFloat32x,   // "_Float32x"
+		TypeSpecifierFloat64,    // "_Float64"
+		TypeSpecifierFloat64x,   // "_Float64x"
+		TypeSpecifierFloat128,   // "_Float128"
+		TypeSpecifierFloat80,    // "__float80"
+		TypeSpecifierDouble,     // "double"
+		TypeSpecifierSigned,     // "signed"
+		TypeSpecifierUnsigned,   // "unsigned"
+		TypeSpecifierBool,       // "_Bool"
+		TypeSpecifierComplex:    // "_Complex"
+		// nop
+	case TypeSpecifierStructOrUnion: // StructOrUnionSpecifier
+		n.StructOrUnionSpecifier.check(ctx, typ, inUnion)
+	case TypeSpecifierEnum: // EnumSpecifier
+		n.EnumSpecifier.check(ctx)
+	case TypeSpecifierTypedefName: // TYPEDEFNAME
+		// nop
+	case TypeSpecifierTypeofExpr: // "typeof" '(' Expression ')'
+		op := n.Expression.check(ctx, false)
+		n.typ = op.Type()
+	case TypeSpecifierTypeofType: // "typeof" '(' TypeName ')'
+		n.typ = n.TypeName.check(ctx, false, false, nil)
+	case TypeSpecifierAtomic: // AtomicTypeSpecifier
+		t := n.AtomicTypeSpecifier.check(ctx)
+		typ.kind = t.base().kind
+		typ.flags |= fAtomic
+		n.typ = typ
+	case
+		TypeSpecifierFract, // "_Fract"
+		TypeSpecifierSat,   // "_Sat"
+		TypeSpecifierAccum: // "_Accum"
+		// nop
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *AtomicTypeSpecifier) check(ctx *context) Type {
+	if n == nil {
+		return nil
+	}
+
+	return n.TypeName.check(ctx, false, false, &n.list)
+}
+
+func (n *EnumSpecifier) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case EnumSpecifierDef: // "enum" AttributeSpecifierList IDENTIFIER '{' EnumeratorList ',' '}'
+		n.AttributeSpecifierList.check(ctx, nil)
+		min, max := n.EnumeratorList.check(ctx)
+		var tmin, tmax Type
+		switch min := min.(type) {
+		case Int64Value:
+			switch {
+			case min >= 0 && ctx.cfg.UnsignedEnums:
+				tmin = n.requireUint(ctx, uint64(min))
+				switch max := max.(type) {
+				case Int64Value:
+					tmax = n.requireUint(ctx, uint64(max))
+				case Uint64Value:
+					tmax = n.requireUint(ctx, uint64(max))
+				case nil:
+					panic(todo("%v:", n.Position()))
+				}
+			default:
+				tmin = n.requireInt(ctx, int64(min))
+				switch max := max.(type) {
+				case Int64Value:
+					tmax = n.requireInt(ctx, int64(max))
+				case Uint64Value:
+					tmax = n.requireInt(ctx, int64(max))
+				case nil:
+					panic(todo("%v:", n.Position()))
+				}
+			}
+		case Uint64Value:
+			tmin = n.requireUint(ctx, uint64(min))
+			switch max := max.(type) {
+			case Int64Value:
+				if max < 0 {
+					panic(todo("%v: min %v max %v", n.Position(), min, max))
+				}
+
+				tmax = n.requireUint(ctx, uint64(max))
+			case Uint64Value:
+				tmax = n.requireUint(ctx, uint64(max))
+			case nil:
+				_ = max
+				panic(todo("%v:", n.Position()))
+			}
+		case nil:
+			panic(todo("%v: %v %T", n.Position(), n.Case, min))
+		}
+		switch {
+		case tmin.Size() > tmax.Size():
+			n.typ = tmin
+		default:
+			n.typ = tmax
+		}
+		if !n.typ.IsIntegerType() || n.typ.Size() == 0 { //TODO-
+			panic(todo(""))
+		}
+
+		reg := n.lexicalScope.Parent() == nil
+		for list := n.EnumeratorList; list != nil; list = list.EnumeratorList {
+			en := list.Enumerator
+			en.Operand = en.Operand.convertTo(ctx, en, n.typ)
+			if reg {
+				ctx.enums[en.Token.Value] = en.Operand
+			}
+		}
+	case EnumSpecifierTag: // "enum" AttributeSpecifierList IDENTIFIER
+		n.typ = &taggedType{
+			resolutionScope: n.lexicalScope,
+			tag:             n.Token2.Value,
+			typeBase:        &typeBase{kind: byte(Enum)},
+		}
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *EnumSpecifier) requireInt(ctx *context, m int64) (r Type) {
+	var w int
+	switch {
+	case m < 0:
+		w = mathutil.BitLenUint64(uint64(-m))
+	default:
+		w = mathutil.BitLenUint64(uint64(m)) + 1
+	}
+	w = mathutil.Max(w, 32)
+	abi := ctx.cfg.ABI
+	for k0, v := range intConvRank {
+		k := Kind(k0)
+		if k == Bool || k == Enum || v == 0 || !abi.isSignedInteger(k) {
+			continue
+		}
+
+		t := abi.Types[k]
+		if int(t.Size)*8 < w {
+			continue
+		}
+
+		if r == nil || t.Size < r.Size() {
+			r = abi.Type(k)
+		}
+	}
+	if r == nil || r.Size() == 0 { //TODO-
+		panic(todo(""))
+	}
+	return r
+}
+
+func (n *EnumSpecifier) requireUint(ctx *context, m uint64) (r Type) {
+	w := mathutil.BitLenUint64(m)
+	w = mathutil.Max(w, 32)
+	abi := ctx.cfg.ABI
+	for k0, v := range intConvRank {
+		k := Kind(k0)
+		if k == Bool || k == Enum || v == 0 || abi.isSignedInteger(k) {
+			continue
+		}
+
+		t := abi.Types[k]
+		if int(t.Size)*8 < w {
+			continue
+		}
+
+		if r == nil || t.Size < r.Size() {
+			r = abi.Type(k)
+		}
+	}
+	if r == nil || r.Size() == 0 { //TODO-
+		panic(todo(""))
+	}
+	return r
+}
+
+func (n *EnumeratorList) check(ctx *context) (min, max Value) {
+	var iota Value
+	for ; n != nil; n = n.EnumeratorList {
+		iota, min, max = n.Enumerator.check(ctx, iota, min, max)
+	}
+	return min, max
+}
+
+func (n *Enumerator) check(ctx *context, iota, min, max Value) (Value, Value, Value) {
+	if n == nil {
+		return nil, nil, nil
+	}
+
+	if iota == nil {
+		iota = Int64Value(0)
+	}
+	switch n.Case {
+	case EnumeratorIdent: // IDENTIFIER AttributeSpecifierList
+		n.AttributeSpecifierList.check(ctx, nil)
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Int), value: iota}).normalize(ctx, n)
+	case EnumeratorExpr: // IDENTIFIER AttributeSpecifierList '=' ConstantExpression
+		n.AttributeSpecifierList.check(ctx, nil)
+		n.Operand = n.ConstantExpression.check(ctx, ctx.mode|mIntConstExpr, false)
+		iota = n.Operand.Value()
+	default:
+		panic(todo(""))
+	}
+	switch x := iota.(type) {
+	case Int64Value:
+		switch m := min.(type) {
+		case Int64Value:
+			if x < m {
+				min = x
+			}
+		case Uint64Value:
+			if x < 0 || Uint64Value(x) < m {
+				min = x
+			}
+		case nil:
+			min = x
+		}
+		switch m := max.(type) {
+		case Int64Value:
+			if x > m {
+				max = x
+			}
+		case Uint64Value:
+			if x >= 0 && Uint64Value(x) > m {
+				max = x
+			}
+		case nil:
+			max = x
+		}
+		x++
+		iota = x
+	case Uint64Value:
+		switch m := min.(type) {
+		case Int64Value:
+			if m < 0 {
+				break
+			}
+
+			if x < Uint64Value(m) {
+				min = x
+			}
+		case Uint64Value:
+			if x < m {
+				min = x
+			}
+		case nil:
+			min = x
+		}
+		switch m := max.(type) {
+		case Int64Value:
+			if m < 0 {
+				max = x
+				break
+			}
+
+			if x > Uint64Value(m) {
+				max = x
+			}
+
+		case Uint64Value:
+			if x > m {
+				max = x
+			}
+		case nil:
+			max = x
+		}
+		x++
+		iota = x
+	case nil:
+		//TODO report type
+	}
+
+	return iota, min, max
+}
+
+func (n *ConstantExpression) check(ctx *context, mode mode, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	ctx.push(mode)
+	n.Operand = n.ConditionalExpression.check(ctx, isAsmArg)
+	ctx.pop()
+	return n.Operand
+}
+
+func (n *StructOrUnionSpecifier) check(ctx *context, typ *typeBase, inUnion bool) Type {
+	if n == nil {
+		return noType
+	}
+
+	switch n.Case {
+	case StructOrUnionSpecifierDef: // StructOrUnion AttributeSpecifierList IDENTIFIER '{' StructDeclarationList '}'
+		typ.kind = byte(n.StructOrUnion.check(ctx))
+		attr := n.AttributeSpecifierList.check(ctx, typ)
+		fields := n.StructDeclarationList.check(ctx, inUnion || typ.Kind() == Union, typ.IsPacked())
+		m := make(map[StringID]*field, len(fields))
+		x := 0
+		for _, v := range fields {
+			if v.name != 0 {
+				v.x = x
+				v.xs = []int{x}
+				x++
+				m[v.name] = v
+			}
+		}
+		t := (&structType{
+			attr:     attr,
+			fields:   fields,
+			m:        m,
+			tag:      n.Token.Value,
+			typeBase: typ,
+		}).check(ctx, n)
+		if typ.Kind() == Union {
+			var k Kind
+			for _, v := range fields {
+				if k == Invalid {
+					k = v.typ.Kind()
+					continue
+				}
+
+				if v.typ.Kind() != k {
+					k = Invalid
+					break
+				}
+			}
+			t.common = k
+		}
+		n.typ = t
+		if nm := n.Token.Value; nm != 0 && n.lexicalScope.Parent() == nil {
+			ctx.structTypes[nm] = t
+		}
+	case StructOrUnionSpecifierTag: // StructOrUnion AttributeSpecifierList IDENTIFIER
+		typ.kind = byte(n.StructOrUnion.check(ctx))
+		attr := n.AttributeSpecifierList.check(ctx, typ.baseP())
+		n.typ = &taggedType{
+			resolutionScope: n.lexicalScope,
+			tag:             n.Token.Value,
+			typeBase:        typ,
+		}
+		if attr != nil {
+			n.typ = &attributedType{n.typ, attr}
+		}
+	default:
+		panic(todo(""))
+	}
+	return n.typ
+}
+
+func (n *StructDeclarationList) check(ctx *context, inUnion, isPacked bool) (s []*field) {
+	for ; n != nil; n = n.StructDeclarationList {
+		s = append(s, n.StructDeclaration.check(ctx, inUnion, isPacked)...)
+	}
+	return s
+}
+
+func (n *StructDeclaration) check(ctx *context, inUnion, isPacked bool) (s []*field) {
+	if n == nil || n.Empty {
+		return nil
+	}
+
+	typ := n.SpecifierQualifierList.check(ctx, inUnion, isPacked, nil)
+	if n.StructDeclaratorList != nil {
+		return n.StructDeclaratorList.check(ctx, n.SpecifierQualifierList, typ, inUnion, isPacked)
+	}
+
+	return []*field{{typ: typ, inUnion: inUnion}}
+}
+
+func (n *StructDeclaratorList) check(ctx *context, td typeDescriptor, typ Type, inUnion, isPacked bool) (s []*field) {
+	for ; n != nil; n = n.StructDeclaratorList {
+		s = append(s, n.StructDeclarator.check(ctx, td, typ, inUnion, isPacked))
+	}
+	return s
+}
+
+func (n *StructDeclarator) check(ctx *context, td typeDescriptor, typ Type, inUnion, isPacked bool) *field {
+	if n == nil {
+		return nil
+	}
+
+	if isPacked {
+		typ.baseP().flags |= fPacked
+	}
+	if n.Declarator != nil {
+		typ = n.Declarator.check(ctx, td, typ, false)
+	}
+	if attr := n.AttributeSpecifierList.check(ctx, typ.baseP()); len(attr) != 0 {
+		typ = &attributedType{typ, attr}
+	}
+	sf := &field{
+		typ:     typ,
+		d:       n,
+		inUnion: inUnion,
+	}
+	switch n.Case {
+	case StructDeclaratorDecl: // Declarator
+		sf.name = n.Declarator.Name()
+	case StructDeclaratorBitField: // Declarator ':' ConstantExpression AttributeSpecifierList
+		sf.isBitField = true
+		sf.typ = &bitFieldType{Type: typ, field: sf}
+		sf.name = n.Declarator.Name()
+		if op := n.ConstantExpression.check(ctx, ctx.mode|mIntConstExpr, false); op.Type().IsIntegerType() {
+			switch x := op.Value().(type) {
+			case Int64Value:
+				if x < 0 || x > 64 {
+					panic("TODO")
+				}
+				sf.bitFieldWidth = byte(x)
+			case Uint64Value:
+				if x > 64 {
+					panic("TODO")
+				}
+				sf.bitFieldWidth = byte(x)
+			default:
+				//dbg("%T", x)
+				panic(PrettyString(op))
+			}
+		} else {
+			//dbg("", n.ConstantExpression)
+			panic(n.Declarator.Position())
+		}
+		n.AttributeSpecifierList.check(ctx, sf.typ.baseP())
+	default:
+		panic(todo(""))
+	}
+	return sf
+}
+
+func (n *StructOrUnion) check(ctx *context) Kind {
+	if n == nil {
+		return Invalid
+	}
+
+	switch n.Case {
+	case StructOrUnionStruct: // "struct"
+		return Struct
+	case StructOrUnionUnion: // "union"
+		return Union
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *CastExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case CastExpressionUnary: // UnaryExpression
+		n.Operand = n.UnaryExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.UnaryExpression.IsSideEffectsFree
+	case CastExpressionCast: // '(' TypeName ')' CastExpression
+		t := n.TypeName.check(ctx, false, false, nil)
+		ctx.push(ctx.mode)
+		if m := ctx.mode; m&mIntConstExpr != 0 && m&mIntConstExprAnyCast == 0 {
+			if t := n.TypeName.Type(); t != nil && t.Kind() != Int {
+				ctx.mode &^= mIntConstExpr
+			}
+			ctx.mode |= mIntConstExprFloat
+		}
+		op := n.CastExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.CastExpression.IsSideEffectsFree
+		ctx.pop()
+		n.Operand = op.convertTo(ctx, n, t)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *PostfixExpression) check(ctx *context, implicitFunc, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+out:
+	switch n.Case {
+	case PostfixExpressionPrimary: // PrimaryExpression
+		n.Operand = n.PrimaryExpression.check(ctx, implicitFunc, isAsmArg)
+		n.IsSideEffectsFree = n.PrimaryExpression.IsSideEffectsFree
+	case PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
+		pe := n.PostfixExpression.check(ctx, false, isAsmArg)
+		if d := pe.Declarator(); d != nil {
+			d.Read += ctx.readDelta
+		}
+		e := n.Expression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.PostfixExpression.IsSideEffectsFree && n.Expression.IsSideEffectsFree
+		t := pe.Type().Decay()
+		if t.Kind() == Invalid {
+			break
+		}
+
+		if t.Kind() == Ptr {
+			if t := e.Type(); t.Kind() != Invalid && !t.IsIntegerType() {
+				ctx.errNode(n.Expression, "index must be integer type, have %v", e.Type())
+				break
+			}
+
+			n.Operand = n.index(ctx, pe, e)
+			break
+		}
+
+		if pe.Type().Kind() == Vector {
+			if t := e.Type(); t.Kind() != Invalid && !t.IsIntegerType() {
+				ctx.errNode(n.Expression, "index must be integer type, have %v", e.Type())
+				break
+			}
+
+			n.Operand = n.index(ctx, pe, e)
+			break
+		}
+
+		t = e.Type().Decay()
+		if t.Kind() == Invalid {
+			break
+		}
+
+		if t.Kind() == Ptr {
+			if t := pe.Type(); t.Kind() != Invalid && !t.IsIntegerType() {
+				ctx.errNode(n.Expression, "index must be integer type, have %v", pe.Type())
+				break
+			}
+
+			n.Operand = n.index(ctx, e, pe)
+			break
+		}
+
+		ctx.errNode(n, "invalid index expression %v[%v]", pe.Type(), e.Type())
+	case PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
+		op := n.PostfixExpression.check(ctx, true, isAsmArg)
+		Inspect(n.PostfixExpression, func(n Node, enter bool) bool {
+			if !enter {
+				return true
+			}
+
+			if x, ok := n.(*PrimaryExpression); ok {
+				if d := x.Declarator(); d != nil {
+					d.called = true
+				}
+			}
+			return true
+		})
+		args := n.ArgumentExpressionList.check(ctx, n.PostfixExpression.Declarator(), isAsmArg)
+		switch op.Declarator().Name() {
+		case idBuiltinConstantPImpl:
+			if len(args) < 2 {
+				panic(todo(""))
+			}
+
+			var v Int64Value
+			if args[1].Value() != nil {
+				v = 1
+			}
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Int), value: v}
+		default:
+			switch n.PostfixExpression.Operand.Value().(type) {
+			case StringValue, WideStringValue:
+				if isAsmArg {
+					// asm("foo": "bar" (a))
+					//            ^
+					break out
+				}
+			}
+
+			n.Operand = n.checkCall(ctx, n, op.Type(), args, n.ArgumentExpressionList)
+		}
+	case PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
+		op := n.PostfixExpression.check(ctx, false, isAsmArg)
+		n.IsSideEffectsFree = n.PostfixExpression.IsSideEffectsFree
+		if d := op.Declarator(); d != nil {
+			d.Read += ctx.readDelta
+		}
+		st := op.Type()
+		st0 := st.underlyingType()
+		if k := st.Kind(); k == Invalid || k != Struct && k != Union {
+			ctx.errNode(n.PostfixExpression, "select expression of wrong type: %s (%s)", st, st0)
+			break
+		}
+
+		f, ok := st.FieldByName(n.Token2.Value)
+		if !ok {
+			ctx.errNode(n.PostfixExpression, "unknown or ambiguous field %q of type %s (%s)", n.Token2.Value, st, st0)
+			break
+		}
+
+		n.Field = f
+		ft := f.Type()
+		if f.IsBitField() {
+			ft = &bitFieldType{Type: ft, field: f.(*field)}
+			n.Operand = &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ft}}
+			break
+		}
+
+		n.Operand = &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ft, offset: op.Offset() + f.Offset()}}
+	case PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
+		op := n.PostfixExpression.check(ctx, false, isAsmArg)
+		n.IsSideEffectsFree = n.PostfixExpression.IsSideEffectsFree
+		if d := op.Declarator(); d != nil {
+			d.Read += ctx.readDelta
+		}
+		t := op.Type()
+		if k := t.Decay().Kind(); k == Invalid || k != Ptr {
+			//TODO report error
+			break
+		}
+
+		st := t.Elem()
+		if k := st.Kind(); k == Invalid || k != Struct && k != Union {
+			//TODO report error
+			break
+		}
+
+		f, ok := st.FieldByName(n.Token2.Value)
+		if !ok {
+			//TODO report error
+			break
+		}
+
+		n.Field = f
+		ft := f.Type()
+		if f.IsBitField() {
+			ft = &bitFieldType{Type: ft, field: f.(*field)}
+		}
+		n.Operand = &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ft}}
+	case PostfixExpressionInc: // PostfixExpression "++"
+		op := n.PostfixExpression.check(ctx, false, isAsmArg)
+		if d := op.Declarator(); d != nil {
+			d.SubjectOfIncDec = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: op.Type()}
+	case PostfixExpressionDec: // PostfixExpression "--"
+		op := n.PostfixExpression.check(ctx, false, isAsmArg)
+		if d := op.Declarator(); d != nil {
+			d.SubjectOfIncDec = true
+			d.Read += ctx.readDelta
+			d.Write++
+		}
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: op.Type()}
+	case PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
+		//TODO IsSideEffectsFree
+		if f := ctx.checkFn; f != nil {
+			f.CompositeLiterals = append(f.CompositeLiterals, n)
+		}
+		t := n.TypeName.check(ctx, false, false, nil)
+		var v *InitializerValue
+		if n.InitializerList != nil {
+			n.InitializerList.check(ctx, &n.InitializerList.list, t, Automatic, 0, nil, false)
+			n.InitializerList.setConstZero()
+			v = &InitializerValue{typ: t, initializer: n.InitializerList}
+		}
+		n.Operand = &lvalue{Operand: (&operand{abi: &ctx.cfg.ABI, typ: t, value: v}).normalize(ctx, n)}
+	case PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
+		n.IsSideEffectsFree = true
+		t1 := n.TypeName.check(ctx, false, false, nil)
+		t2 := n.TypeName2.check(ctx, false, false, nil)
+		v := 0
+		switch {
+		case t1.IsArithmeticType() && t2.IsArithmeticType():
+			if t1.Kind() == t2.Kind() {
+				v = 1
+			}
+		default:
+			ctx.errNode(n, "ICE: __builtin_types_compatible_p(%v, %v)", t1, t2)
+		}
+		n.Operand = &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Int), value: Int64Value(v)}
+	case PostfixExpressionChooseExpr: // "__builtin_choose_expr" '(' ConstantExpression ',' AssignmentExpression ',' AssignmentExpression ')'
+		n.Operand = noOperand
+		expr1 := n.AssignmentExpression.check(ctx, isAsmArg)
+		if expr1 == nil {
+			ctx.errNode(n, "first argument of __builtin_choose_expr must be a constant expression")
+			break
+		}
+
+		if !expr1.IsConst() {
+			ctx.errNode(n, "first argument of __builtin_choose_expr must be a constant expression: %v %v", expr1.Value(), expr1.Type())
+			break
+		}
+
+		switch {
+		case expr1.IsNonZero():
+			n.Operand = n.AssignmentExpression2.check(ctx, isAsmArg)
+			n.IsSideEffectsFree = n.AssignmentExpression2.IsSideEffectsFree
+		default:
+			n.Operand = n.AssignmentExpression3.check(ctx, isAsmArg)
+			n.IsSideEffectsFree = n.AssignmentExpression3.IsSideEffectsFree
+		}
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *PostfixExpression) index(ctx *context, pe, e Operand) Operand {
+	var x uintptr
+	hasx := false
+	switch v := e.Value().(type) {
+	case Int64Value:
+		x = uintptr(v)
+		hasx = true
+	case Uint64Value:
+		x = uintptr(v)
+		hasx = true
+	}
+	off := x * pe.Type().Elem().Size()
+	switch v := pe.Value().(type) {
+	case StringValue:
+		if hasx {
+			s := StringID(v).String()
+			var v byte
+			switch {
+			case x > uintptr(len(s)):
+				//TODO report err
+				return noOperand
+			case x < uintptr(len(s)):
+				v = s[x]
+			}
+
+			return (&operand{abi: &ctx.cfg.ABI, typ: pe.Type().Elem(), value: Int64Value(v)}).normalize(ctx, n)
+		}
+	case WideStringValue:
+		if hasx {
+			s := []rune(StringID(v).String())
+			var v rune
+			switch {
+			case x > uintptr(len(s)):
+				//TODO report err
+				return noOperand
+			case x < uintptr(len(s)):
+				v = s[x]
+			}
+
+			return (&operand{abi: &ctx.cfg.ABI, typ: pe.Type().Elem(), value: Int64Value(v)}).normalize(ctx, n)
+		}
+	}
+
+	if d := pe.Declarator(); d != nil && hasx {
+		return &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: pe.Type().Elem(), offset: pe.Offset() + off}, declarator: d}
+	}
+
+	return &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: pe.Type().Elem()}}
+}
+
+func (n *PostfixExpression) checkCall(ctx *context, nd Node, f Type, args []Operand, argList *ArgumentExpressionList) (r Operand) {
+	r = noOperand
+	switch f.Kind() {
+	case Invalid:
+		return noOperand
+	case Function:
+		// ok
+	case Ptr:
+		if e := f.Elem(); e.Kind() == Function {
+			f = e
+			break
+		}
+
+		ctx.errNode(nd, "expected function pointer type: %v, %v", f, f.Kind())
+		return r
+	default:
+		ctx.errNode(nd, "expected function type: %v, %v", f, f.Kind())
+		return r
+	}
+
+	r = &operand{abi: &ctx.cfg.ABI, typ: f.Result()}
+	params := f.Parameters()
+	if len(params) == 1 && params[0].Type().Kind() == Void {
+		params = nil
+		if len(args) != 0 {
+			//TODO report error
+			return r
+		}
+	}
+
+	for i, arg := range args {
+		var t Type
+		switch {
+		case i < len(params):
+			//TODO check assignability
+			t = params[i].Type().Decay()
+		default:
+			t = defaultArgumentPromotion(ctx, nd, arg).Type()
+		}
+		argList.AssignmentExpression.promote = t
+		argList = argList.ArgumentExpressionList
+	}
+	return r
+}
+
+func defaultArgumentPromotion(ctx *context, n Node, op Operand) Operand {
+	t := op.Type().Decay()
+	if arithmeticTypes[t.Kind()] {
+		if t.IsIntegerType() {
+			return op.integerPromotion(ctx, n)
+		}
+
+		switch t.Kind() {
+		case Float:
+			return op.convertTo(ctx, n, ctx.cfg.ABI.Type(Double))
+		}
+	}
+	return op
+}
+
+func (n *ArgumentExpressionList) check(ctx *context, f *Declarator, isAsmArg bool) (r []Operand) {
+	for ; n != nil; n = n.ArgumentExpressionList {
+		op := n.AssignmentExpression.check(ctx, isAsmArg)
+		if op.Type() == nil {
+			ctx.errNode(n, "operand has usupported, invalid or incomplete type")
+			op = noOperand
+		} else if op.Type().IsComplexType() {
+			ctx.checkFn.CallSiteComplexExpr = append(ctx.checkFn.CallSiteComplexExpr, n.AssignmentExpression)
+		}
+		r = append(r, op)
+		if !ctx.cfg.TrackAssignments {
+			continue
+		}
+
+		Inspect(n.AssignmentExpression, func(n Node, enter bool) bool {
+			if !enter {
+				return true
+			}
+
+			if x, ok := n.(*PrimaryExpression); ok {
+				x.Declarator().setLHS(f)
+			}
+			return true
+		})
+	}
+	return r
+}
+
+func (n *Expression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case ExpressionAssign: // AssignmentExpression
+		n.Operand = n.AssignmentExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.AssignmentExpression.IsSideEffectsFree
+	case ExpressionComma: // Expression ',' AssignmentExpression
+		op := n.Expression.check(ctx, isAsmArg)
+		n.Operand = n.AssignmentExpression.check(ctx, isAsmArg)
+		if !op.IsConst() && n.Operand.IsConst() {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: n.Operand.Type()}
+		}
+		n.IsSideEffectsFree = n.Expression.IsSideEffectsFree && n.AssignmentExpression.IsSideEffectsFree
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *PrimaryExpression) check(ctx *context, implicitFunc, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case PrimaryExpressionIdent: // IDENTIFIER
+		n.IsSideEffectsFree = true
+		return n.checkIdentifier(ctx, implicitFunc)
+	case PrimaryExpressionInt: // INTCONST
+		n.IsSideEffectsFree = true
+		n.Operand = n.intConst(ctx)
+	case PrimaryExpressionFloat: // FLOATCONST
+		n.IsSideEffectsFree = true
+		if ctx.mode&mIntConstExpr != 0 && ctx.mode&mIntConstExprFloat == 0 {
+			ctx.errNode(n, "invalid integer constant expression")
+			break
+		}
+
+		n.Operand = n.floatConst(ctx)
+	case PrimaryExpressionEnum: // ENUMCONST
+		n.IsSideEffectsFree = true
+		if e := n.resolvedIn.enumerator(n.Token.Value, n.Token); e != nil {
+			op := e.Operand.(*operand)
+			op.typ = ctx.cfg.ABI.Type(Int) //  [0] 6.4.4.3/2
+			n.Operand = op
+			break
+		}
+
+		//TODO report err
+	case PrimaryExpressionChar: // CHARCONST
+		n.IsSideEffectsFree = true
+		s := []rune(n.Token.Value.String())
+		var v Value
+		switch {
+		case s[0] <= 255:
+			// If an integer character constant contains a single character or escape
+			// sequence, its value is the one that results when an object with type char
+			// whose value is that of the single character or escape sequence is converted
+			// to type int.
+			switch {
+			case ctx.cfg.ABI.SignedChar:
+				v = Int64Value(int8(s[0]))
+			default:
+				v = Int64Value(s[0])
+			}
+		default:
+			v = Int64Value(s[0])
+		}
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Int), value: v}).normalize(ctx, n)
+	case PrimaryExpressionLChar: // LONGCHARCONST
+		n.IsSideEffectsFree = true
+		s := []rune(n.Token.Value.String())
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: wcharT(ctx, n.lexicalScope, n.Token), value: Int64Value(s[0])}).normalize(ctx, n)
+	case PrimaryExpressionString: // STRINGLITERAL
+		n.IsSideEffectsFree = true
+		ctx.not(n, mIntConstExpr)
+		typ := ctx.cfg.ABI.Type(Char)
+		b := typ.base()
+		b.align = byte(typ.Align())
+		b.fieldAlign = byte(typ.FieldAlign())
+		b.kind = byte(Array)
+		sz := uintptr(len(n.Token.Value.String())) + 1 //TODO set sz in cpp
+		arr := &arrayType{typeBase: b, decay: ctx.cfg.ABI.Ptr(n, typ), elem: typ, length: sz}
+		arr.setLen(sz)
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: arr, value: StringValue(n.Token.Value)}).normalize(ctx, n)
+	case PrimaryExpressionLString: // LONGSTRINGLITERAL
+		n.IsSideEffectsFree = true
+		ctx.not(n, mIntConstExpr)
+		typ := wcharT(ctx, n.lexicalScope, n.Token)
+		b := typ.base()
+		b.align = byte(typ.Align())
+		b.fieldAlign = byte(typ.FieldAlign())
+		b.kind = byte(Array)
+		sz := uintptr(len([]rune(n.Token.Value.String()))) + 1 //TODO set sz in cpp
+		arr := &arrayType{typeBase: b, decay: ctx.cfg.ABI.Ptr(n, typ), elem: typ, length: sz}
+		arr.setLen(sz)
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: arr, value: WideStringValue(n.Token.Value)}).normalize(ctx, n)
+	case PrimaryExpressionExpr: // '(' Expression ')'
+		n.Operand = n.Expression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.Expression.IsSideEffectsFree
+	case PrimaryExpressionStmt: // '(' CompoundStatement ')'
+		//TODO IsSideEffectsFree
+		ctx.not(n, mIntConstExpr)
+		n.Operand = n.CompoundStatement.check(ctx)
+		if n.Operand == noOperand {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Void)}
+		}
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func wcharT(ctx *context, s Scope, tok Token) Type {
+	if t := ctx.wcharT; t != nil {
+		return t
+	}
+
+	t := ctx.stddef(idWCharT, s, tok)
+	if t.Kind() != Invalid {
+		ctx.wcharT = t
+	}
+	return t
+}
+
+func (n *PrimaryExpression) checkIdentifier(ctx *context, implicitFunc bool) Operand {
+	ctx.not(n, mIntConstExpr)
+	var d *Declarator
+	nm := n.Token.Value
+	if n.resolvedIn == nil {
+		if ctx.cfg.RejectLateBinding && !ctx.cfg.ignoreUndefinedIdentifiers {
+			ctx.errNode(n, "front-end: undefined: %s", n.Token.Value)
+			return noOperand
+		}
+
+	out:
+		for s := n.lexicalScope; s != nil; s = s.Parent() {
+			for _, v := range s[nm] {
+				switch x := v.(type) {
+				case *Enumerator:
+					break out
+				case *Declarator:
+					if x.IsTypedefName {
+						d = nil
+						break out
+					}
+
+					n.resolvedIn = s
+					n.resolvedTo = x
+					d = x
+					t := d.Type()
+					if t != nil && t.Kind() == Function {
+						if d.fnDef {
+							break out
+						}
+
+						continue
+					}
+
+					if t != nil && !t.IsIncomplete() {
+						break out
+					}
+				case *EnumSpecifier, *StructOrUnionSpecifier, *StructDeclarator, *LabeledStatement:
+					// nop
+				default:
+					panic(todo(""))
+				}
+			}
+		}
+	}
+	if d == nil && n.resolvedIn != nil {
+		d = n.resolvedIn.declarator(n.Token.Value, n.Token)
+	}
+	if d == nil && !ctx.cfg.DisableBuiltinResolution {
+		d = builtin(ctx, nm)
+	}
+	if d == nil {
+		_, ok := gccKeywords[nm]
+		if !ok && implicitFunc {
+			d := &Declarator{
+				DirectDeclarator: &DirectDeclarator{
+					lexicalScope: ctx.ast.Scope,
+					Case:         DirectDeclaratorFuncIdent,
+					DirectDeclarator: &DirectDeclarator{
+						lexicalScope: ctx.ast.Scope,
+						Case:         DirectDeclaratorIdent,
+						Token:        Token{Value: nm},
+					},
+				},
+				implicit: true,
+			}
+			ed := &ExternalDeclaration{
+				Case: ExternalDeclarationDecl,
+				Declaration: &Declaration{
+					DeclarationSpecifiers: &DeclarationSpecifiers{
+						Case: DeclarationSpecifiersTypeSpec,
+						TypeSpecifier: &TypeSpecifier{
+							Case: TypeSpecifierInt,
+						},
+					},
+					InitDeclaratorList: &InitDeclaratorList{
+						InitDeclarator: &InitDeclarator{
+							Case:       InitDeclaratorDecl,
+							Declarator: d,
+						},
+					},
+				},
+			}
+			ed.check(ctx)
+			n.Operand = &funcDesignator{Operand: &operand{abi: &ctx.cfg.ABI, typ: d.Type()}, declarator: d}
+			return n.Operand
+		}
+
+		if !ctx.cfg.ignoreUndefinedIdentifiers {
+			ctx.errNode(n, "front-end: undefined: %s", n.Token.Value)
+		}
+		return noOperand
+	}
+	if d == nil {
+		if !ctx.cfg.ignoreUndefinedIdentifiers {
+			ctx.errNode(n, "front-end: undefined: %s", n.Token.Value)
+		}
+		return noOperand
+	}
+
+	switch d.Linkage {
+	case Internal:
+		if d.IsStatic() {
+			break
+		}
+
+		fallthrough
+	case External:
+		s := n.resolvedIn
+		if s.Parent() == nil {
+			break
+		}
+
+		for s.Parent() != nil {
+			s = s.Parent()
+		}
+
+		if d2 := s.declarator(n.Token.Value, Token{}); d2 != nil {
+			d = d2
+		}
+	}
+
+	if d.Type() == nil {
+		ctx.errNode(d, "unresolved type of: %s", n.Token.Value)
+		return noOperand
+	}
+
+	d.Read += ctx.readDelta
+	switch t := d.Type(); t.Kind() {
+	case Function:
+		n.Operand = &funcDesignator{Operand: &operand{abi: &ctx.cfg.ABI, typ: t}, declarator: d}
+	default:
+		n.Operand = &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: t}, declarator: d}
+	}
+	if !ctx.capture {
+		return n.Operand
+	}
+
+	for s := n.lexicalScope; s != nil; s = s.Parent() {
+		if _, ok := s[nm]; ok {
+			return n.Operand // d in fn scope
+		}
+
+		if _, ok := s[idClosure]; ok { // d in outer scope
+			if ctx.closure == nil {
+				ctx.closure = map[StringID]struct{}{} //TODO capture the PrimaryExpression, not the declarator name
+			}
+			ctx.closure[nm] = struct{}{}
+			return n.Operand
+		}
+	}
+	panic(todo(""))
+}
+
+func builtin(ctx *context, nm StringID) *Declarator {
+	id := dict.sid("__builtin_" + nm.String())
+	a := ctx.ast.Scope[id]
+	if len(a) == 0 {
+		return nil
+	}
+
+	switch x := a[0].(type) {
+	case *Declarator:
+		if x.fnDef || x.IsFunctionPrototype() {
+			return x
+		}
+	}
+	return nil
+}
+
+func (n *PrimaryExpression) floatConst(ctx *context) Operand {
+	s0 := n.Token.String()
+	s := s0
+	var cplx, suff string
+loop2:
+	for i := len(s) - 1; i > 0; i-- {
+		switch s0[i] {
+		case 'l', 'L':
+			s = s[:i]
+			if ctx.cfg.LongDoubleIsDouble {
+				break
+			}
+
+			suff += "l"
+		case 'f', 'F':
+			s = s[:i]
+			suff += "f"
+		case 'i', 'I', 'j', 'J':
+			s = s[:i]
+			cplx += "i"
+		default:
+			break loop2
+		}
+	}
+
+	if len(suff) > 1 || len(cplx) > 1 {
+		ctx.errNode(n, "invalid number format")
+		return noOperand
+	}
+
+	var v float64
+	var err error
+	prec := uint(64)
+	if suff == "l" {
+		prec = longDoublePrec
+	}
+	var bf *big.Float
+	switch {
+	case suff == "l" || strings.Contains(s, "p") || strings.Contains(s, "P"):
+		bf, _, err = big.ParseFloat(strings.ToLower(s), 0, prec, big.ToNearestEven)
+		if err == nil {
+			v, _ = bf.Float64()
+		}
+	default:
+		v, err = strconv.ParseFloat(s, 64)
+	}
+	if err != nil {
+		switch {
+		case !strings.HasPrefix(s, "-") && strings.Contains(err.Error(), "value out of range"):
+			// linux_386/usr/include/math.h
+			//
+			// 	/* Value returned on overflow.  With IEEE 754 floating point, this is
+			// 	   +Infinity, otherwise the largest representable positive value.  */
+			// 	#if __GNUC_PREREQ (3, 3)
+			// 	# define HUGE_VAL (__builtin_huge_val ())
+			// 	#else
+			// 	/* This may provoke compiler warnings, and may not be rounded to
+			// 	   +Infinity in all IEEE 754 rounding modes, but is the best that can
+			// 	   be done in ISO C while remaining a constant expression.  10,000 is
+			// 	   greater than the maximum (decimal) exponent for all supported
+			// 	   floating-point formats and widths.  */
+			// 	# define HUGE_VAL 1e10000
+			// 	#endif
+			v = math.Inf(1)
+		default:
+			ctx.errNode(n, "%v", err)
+			return noOperand
+		}
+	}
+
+	// [0]6.4.4.2
+	switch suff {
+	case "":
+		switch {
+		case cplx != "":
+			return (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(ComplexDouble), value: Complex128Value(complex(0, v))}).normalize(ctx, n)
+		default:
+			return (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Double), value: Float64Value(v)}).normalize(ctx, n)
+		}
+	case "f":
+		switch {
+		case cplx != "":
+			return (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(ComplexFloat), value: Complex64Value(complex(0, float32(v)))}).normalize(ctx, n)
+		default:
+			return (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Float), value: Float32Value(float32(v))}).normalize(ctx, n)
+		}
+	case "l":
+		switch {
+		case cplx != "":
+			return (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(ComplexLongDouble), value: Complex256Value{&Float128Value{N: big.NewFloat(0)}, &Float128Value{N: bf}}}).normalize(ctx, n)
+		default:
+			return (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(LongDouble), value: &Float128Value{N: bf}}).normalize(ctx, n)
+		}
+	default:
+		//dbg("%q %q %q %q %v", s0, s, suff, cplx, err)
+		panic("TODO")
+	}
+}
+
+func (n *PrimaryExpression) intConst(ctx *context) Operand {
+	var val uint64
+	s0 := n.Token.String()
+	s := strings.TrimRight(s0, "uUlL")
+	var decadic bool
+	switch {
+	case strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X"):
+		var err error
+		if val, err = strconv.ParseUint(s[2:], 16, 64); err != nil {
+			ctx.errNode(n, "%v", err)
+			return nil
+		}
+	case strings.HasPrefix(s, "0b") || strings.HasPrefix(s, "0B"):
+		var err error
+		if val, err = strconv.ParseUint(s[2:], 2, 64); err != nil {
+			ctx.errNode(n, "%v", err)
+			return nil
+		}
+	case strings.HasPrefix(s, "0"):
+		var err error
+		if val, err = strconv.ParseUint(s, 8, 64); err != nil {
+			ctx.errNode(n, "%v", err)
+			return nil
+		}
+	default:
+		decadic = true
+		var err error
+		if val, err = strconv.ParseUint(s, 10, 64); err != nil {
+			ctx.errNode(n, "%v", err)
+			return nil
+		}
+	}
+
+	suffix := s0[len(s):]
+	switch suffix = strings.ToLower(suffix); suffix {
+	case "":
+		if decadic {
+			return intConst(ctx, n, s0, val, Int, Long, LongLong)
+		}
+
+		return intConst(ctx, n, s0, val, Int, UInt, Long, ULong, LongLong, ULongLong)
+	case "u":
+		return intConst(ctx, n, s0, val, UInt, ULong, ULongLong)
+	case "l":
+		if decadic {
+			return intConst(ctx, n, s0, val, Long, LongLong)
+		}
+
+		return intConst(ctx, n, s0, val, Long, ULong, LongLong, ULongLong)
+	case "lu", "ul":
+		return intConst(ctx, n, s0, val, ULong, ULongLong)
+	case "ll":
+		if decadic {
+			return intConst(ctx, n, s0, val, LongLong)
+		}
+
+		return intConst(ctx, n, s0, val, LongLong, ULongLong)
+	case "llu", "ull":
+		return intConst(ctx, n, s0, val, ULongLong)
+	default:
+		ctx.errNode(n, "invalid suffix: %v", s0)
+		return nil
+	}
+}
+
+func intConst(ctx *context, n Node, s string, val uint64, list ...Kind) Operand {
+	abi := ctx.cfg.ABI
+	b := bits.Len64(val)
+	for _, k := range list {
+		sign := 0
+		if abi.isSignedInteger(k) {
+			sign = 1
+		}
+		if abi.size(k)*8 >= b+sign {
+			switch {
+			case sign == 0:
+				return (&operand{abi: &ctx.cfg.ABI, typ: abi.Type(k), value: Uint64Value(val)}).normalize(ctx, n)
+			default:
+				return (&operand{abi: &ctx.cfg.ABI, typ: abi.Type(k), value: Int64Value(val)}).normalize(ctx, n)
+			}
+		}
+	}
+
+	ctx.errNode(n, "invalid integer constant %v", s)
+	return nil
+}
+
+func (n *ConditionalExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case ConditionalExpressionLOr: // LogicalOrExpression
+		n.Operand = n.LogicalOrExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.LogicalOrExpression.IsSideEffectsFree
+	case ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
+		op := n.LogicalOrExpression.check(ctx, isAsmArg)
+		// The first operand shall have scalar type.
+		if !op.Type().Decay().IsScalarType() {
+			//TODO report error
+			break
+		}
+
+		a := n.Expression.check(ctx, isAsmArg)
+		b := n.ConditionalExpression.check(ctx, isAsmArg)
+		at := a.Type().Decay()
+		bt := b.Type().Decay()
+
+		n.IsSideEffectsFree = n.LogicalOrExpression.IsSideEffectsFree && (n.Expression == nil || n.Expression.IsSideEffectsFree) && n.ConditionalExpression.IsSideEffectsFree
+		var val Value
+		if op.Value() != nil {
+			switch {
+			case op.IsZero():
+				n.IsSideEffectsFree = n.LogicalOrExpression.IsSideEffectsFree && n.ConditionalExpression.IsSideEffectsFree
+			default:
+				n.IsSideEffectsFree = n.LogicalOrExpression.IsSideEffectsFree && n.Expression.IsSideEffectsFree
+			}
+			if a.Value() != nil && b.Value() != nil { //TODO not needed both non nil
+				switch {
+				case op.IsZero():
+					val = b.Value()
+				default:
+					val = a.Value()
+				}
+			}
+		}
+
+		if a.Type().Kind() == Invalid && b.Type().Kind() == Invalid {
+			return noOperand
+		}
+
+		// One of the following shall hold for the second and third
+		// operands:
+		//TODO — both operands have the same structure or union type;
+		//TODO — one operand is a pointer to an object or incomplete type and the other is a pointer to a
+		//TODO qualified or unqualified version of void.
+		switch {
+		// — both operands have arithmetic type;
+		case a.Type().IsArithmeticType() && b.Type().IsArithmeticType():
+			// If both the second and third operands have
+			// arithmetic type, the result type that would be
+			// determined by the usual arithmetic conversions, were
+			// they applied to those two operands,
+			// is the type of the result.
+			op, _ := usualArithmeticConversions(ctx, n, a, b, true)
+			n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: op.Type(), value: val}).normalize(ctx, n)
+		// — both operands have void type;
+		case a.Type().Kind() == Void && b.Type().Kind() == Void:
+			n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: val}).normalize(ctx, n)
+		// — one operand is a pointer and the other is a null pointer constant;
+		case (a.Type().Kind() == Ptr || a.Type().Kind() == Function) && b.IsZero():
+			n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: val}).normalize(ctx, n)
+		case (b.Type().Kind() == Ptr || b.Type().Kind() == Function) && a.IsZero():
+			n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: b.Type(), value: val}).normalize(ctx, n)
+		// — both operands are pointers to qualified or unqualified versions of compatible types;
+		case at.Kind() == Ptr && bt.Kind() == Ptr:
+			//TODO check compatible
+			//TODO if !at.isCompatibleIgnoreQualifiers(bt) {
+			//TODO 	trc("%v: XXXX %v ? %v", n.Token2.Position(), at, bt)
+			//TODO 	ctx.assignmentCompatibilityErrorCond(&n.Token2, at, bt)
+			//TODO }
+			n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: n.Expression.Operand.Type(), value: val}).normalize(ctx, n)
+		case a.Type().Kind() == Ptr && a.Type().Elem().Kind() == Function && b.Type().Kind() == Function:
+			//TODO check compatible
+			n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: val}).normalize(ctx, n)
+		case b.Type().Kind() == Ptr && b.Type().Elem().Kind() == Function && a.Type().Kind() == Function:
+			//TODO check compatible
+			n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: b.Type(), value: val}).normalize(ctx, n)
+		case a.Type().Kind() != Invalid:
+			n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: val}).normalize(ctx, n)
+		case b.Type().Kind() != Invalid:
+			n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: b.Type(), value: val}).normalize(ctx, n)
+		default:
+			panic(todo(""))
+		}
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *LogicalOrExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case LogicalOrExpressionLAnd: // LogicalAndExpression
+		n.Operand = n.LogicalAndExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.LogicalAndExpression.IsSideEffectsFree
+	case LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
+		lop := n.LogicalOrExpression.check(ctx, isAsmArg)
+		rop := n.LogicalAndExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.LogicalOrExpression.IsSideEffectsFree && n.LogicalAndExpression.IsSideEffectsFree ||
+			lop.Value() != nil && lop.IsNonZero() && n.LogicalOrExpression.IsSideEffectsFree
+		var v Value
+		if lop.Value() != nil && rop.Value() != nil { //TODO lop.IsNonZero shortcut
+			switch {
+			case n.LogicalOrExpression.Operand.IsNonZero() || n.LogicalAndExpression.Operand.IsNonZero():
+				v = Int64Value(1)
+			default:
+				v = Int64Value(0)
+			}
+		}
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Int), value: v}).normalize(ctx, n)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *LogicalAndExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case LogicalAndExpressionOr: // InclusiveOrExpression
+		n.Operand = n.InclusiveOrExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.InclusiveOrExpression.IsSideEffectsFree
+	case LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
+		lop := n.LogicalAndExpression.check(ctx, isAsmArg)
+		rop := n.InclusiveOrExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.LogicalAndExpression.IsSideEffectsFree && n.InclusiveOrExpression.IsSideEffectsFree ||
+			lop.Value() != nil && lop.IsZero() && n.LogicalAndExpression.IsSideEffectsFree
+		var v Value
+		if lop.Value() != nil && rop.Value() != nil { //TODO lop.IsZero shortcut
+			switch {
+			case n.LogicalAndExpression.Operand.IsNonZero() && n.InclusiveOrExpression.Operand.IsNonZero():
+				v = Int64Value(1)
+			default:
+				v = Int64Value(0)
+			}
+		}
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Int), value: v}).normalize(ctx, n)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *InclusiveOrExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case InclusiveOrExpressionXor: // ExclusiveOrExpression
+		n.Operand = n.ExclusiveOrExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.ExclusiveOrExpression.IsSideEffectsFree
+	case InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
+		a := n.InclusiveOrExpression.check(ctx, isAsmArg)
+		b := n.ExclusiveOrExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.InclusiveOrExpression.IsSideEffectsFree && n.ExclusiveOrExpression.IsSideEffectsFree
+		n.promote = noType
+		if a.Type().Kind() == Vector || b.Type().Kind() == Vector {
+			n.Operand = checkBinaryVectorIntegerArtithmetic(ctx, n, a, b)
+			break
+		}
+
+		if !a.Type().IsIntegerType() || !b.Type().IsIntegerType() {
+			ctx.errNode(n, "operands must be integers")
+			break
+		}
+
+		a, b = usualArithmeticConversions(ctx, &n.Token, a, b, true)
+		n.promote = a.Type()
+		if a.Value() == nil || b.Value() == nil {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: a.Type()}
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: a.Value().or(b.Value())}).normalize(ctx, n)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func checkBinaryVectorIntegerArtithmetic(ctx *context, n Node, a, b Operand) Operand {
+	var rt Type
+	if a.Type().Kind() == Vector {
+		rt = a.Type()
+		a = &operand{abi: &ctx.cfg.ABI, typ: a.Type().Elem()}
+	}
+	if b.Type().Kind() == Vector {
+		if rt == nil {
+			rt = b.Type()
+		}
+		b = &operand{abi: &ctx.cfg.ABI, typ: b.Type().Elem()}
+	}
+	a, b = usualArithmeticConversions(ctx, n, a, b, true)
+	if !a.Type().IsIntegerType() || !b.Type().IsIntegerType() {
+		ctx.errNode(n, "operands must be integers")
+	}
+	return &operand{abi: &ctx.cfg.ABI, typ: rt}
+}
+
+func (n *ExclusiveOrExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case ExclusiveOrExpressionAnd: // AndExpression
+		n.Operand = n.AndExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.AndExpression.IsSideEffectsFree
+	case ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
+		a := n.ExclusiveOrExpression.check(ctx, isAsmArg)
+		b := n.AndExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.ExclusiveOrExpression.IsSideEffectsFree && n.AndExpression.IsSideEffectsFree
+		if a.Type().Kind() == Vector || b.Type().Kind() == Vector {
+			n.Operand = checkBinaryVectorIntegerArtithmetic(ctx, n, a, b)
+			break
+		}
+
+		if !a.Type().IsIntegerType() || !b.Type().IsIntegerType() {
+			ctx.errNode(n, "operands must be integers")
+			break
+		}
+
+		a, b = usualArithmeticConversions(ctx, &n.Token, a, b, true)
+		n.promote = a.Type()
+		if a.Value() == nil || b.Value() == nil {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: a.Type()}
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: a.Value().xor(b.Value())}).normalize(ctx, n)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *AndExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case AndExpressionEq: // EqualityExpression
+		n.Operand = n.EqualityExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.EqualityExpression.IsSideEffectsFree
+	case AndExpressionAnd: // AndExpression '&' EqualityExpression
+		a := n.AndExpression.check(ctx, isAsmArg)
+		b := n.EqualityExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.AndExpression.IsSideEffectsFree && n.EqualityExpression.IsSideEffectsFree
+		if a.Type().Kind() == Vector || b.Type().Kind() == Vector {
+			n.Operand = checkBinaryVectorIntegerArtithmetic(ctx, n, a, b)
+			break
+		}
+
+		if !a.Type().IsIntegerType() || !b.Type().IsIntegerType() {
+			ctx.errNode(n, "operands must be integers")
+			break
+		}
+
+		a, b = usualArithmeticConversions(ctx, &n.Token, a, b, true)
+		n.promote = a.Type()
+		if a.Value() == nil || b.Value() == nil {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: a.Type()}
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: a.Value().and(b.Value())}).normalize(ctx, n)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *EqualityExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	switch n.Case {
+	case EqualityExpressionRel: // RelationalExpression
+		n.Operand = n.RelationalExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.RelationalExpression.IsSideEffectsFree
+	case
+		EqualityExpressionEq,  // EqualityExpression "==" RelationalExpression
+		EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
+
+		op := &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Int)}
+		n.Operand = op
+		lo := n.EqualityExpression.check(ctx, isAsmArg)
+		ro := n.RelationalExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.EqualityExpression.IsSideEffectsFree && n.RelationalExpression.IsSideEffectsFree
+		lt := lo.Type().Decay()
+		rt := ro.Type().Decay()
+		n.promote = noType
+		ok := false
+		switch {
+		case lo.Type().Kind() == Vector && ro.Type().Kind() == Vector:
+			n.Operand = checkVectorComparison(ctx, n, lo.Type(), ro.Type())
+			return n.Operand
+		case lt.IsArithmeticType() && rt.IsArithmeticType():
+			op, _ := usualArithmeticConversions(ctx, n, lo, ro, true)
+			n.promote = op.Type()
+			ok = true
+		case lt.Kind() == Ptr && (rt.Kind() == Ptr || rt.IsIntegerType()):
+			n.promote = lt
+			//TODO
+		case (lt.Kind() == Ptr || lt.IsIntegerType()) && rt.Kind() == Ptr:
+			n.promote = rt
+			//TODO
+		case lt.Kind() == Function:
+			n.promote = ctx.cfg.ABI.Ptr(n, lt)
+		case rt.Kind() == Function:
+			n.promote = ctx.cfg.ABI.Ptr(n, rt)
+		default:
+			//TODO report error
+		}
+		if n.promote.Kind() == Invalid || !ok {
+			break
+		}
+
+		lo = lo.convertTo(ctx, n, n.promote)
+		ro = ro.convertTo(ctx, n, n.promote)
+		if a, b := lo.Value(), ro.Value(); a != nil && b != nil {
+			switch n.Case {
+			case EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
+				op.value = a.eq(b)
+			case EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
+				op.value = a.neq(b)
+			}
+		}
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func checkVectorComparison(ctx *context, n Node, a, b Type) (r Operand) {
+	a = a.underlyingType()
+	b = b.underlyingType()
+	rt := *a.(*vectorType)
+	rt.elem = ctx.cfg.ABI.Type(Int)
+	r = &operand{abi: &ctx.cfg.ABI, typ: &rt}
+	x := a.Elem()
+	y := b.Elem()
+	if x.Kind() != y.Kind() {
+		ctx.errNode(n, "cannot compare vectors of different element types: %s and %s", x, y)
+	}
+	return r
+}
+
+func (n *RelationalExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case RelationalExpressionShift: // ShiftExpression
+		n.Operand = n.ShiftExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.ShiftExpression.IsSideEffectsFree
+	case
+		RelationalExpressionLt,  // RelationalExpression '<' ShiftExpression
+		RelationalExpressionGt,  // RelationalExpression '>' ShiftExpression
+		RelationalExpressionLeq, // RelationalExpression "<=" ShiftExpression
+		RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
+
+		n.promote = noType
+		op := &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Type(Int)}
+		n.Operand = op
+		lo := n.RelationalExpression.check(ctx, isAsmArg)
+		ro := n.ShiftExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.RelationalExpression.IsSideEffectsFree && n.ShiftExpression.IsSideEffectsFree
+		if lo.Type().Kind() == Vector && ro.Type().Kind() == Vector {
+			n.Operand = checkVectorComparison(ctx, n, lo.Type(), ro.Type())
+			break
+		}
+
+		if lo.Type().IsComplexType() || ro.Type().IsComplexType() {
+			ctx.errNode(&n.Token, "complex numbers are not ordered")
+			break
+		}
+
+		lt := lo.Type().Decay()
+		rt := ro.Type().Decay()
+		n.promote = noType
+		ok := true
+		switch {
+		case lt.IsRealType() && rt.IsRealType():
+			op, _ := usualArithmeticConversions(ctx, n, lo, ro, true)
+			n.promote = op.Type()
+		case lt.Kind() == Ptr && (rt.Kind() == Ptr || rt.IsIntegerType()):
+			n.promote = lt
+			//TODO
+		case (lt.Kind() == Ptr || lt.IsIntegerType()) && rt.Kind() == Ptr:
+			n.promote = rt
+			//TODO
+		default:
+			//TODO report error
+			ok = false
+		}
+		if n.promote.Kind() == Invalid || !ok {
+			break
+		}
+
+		lo = lo.convertTo(ctx, n, n.promote)
+		ro = ro.convertTo(ctx, n, n.promote)
+		if a, b := lo.Value(), ro.Value(); a != nil && b != nil {
+			switch n.Case {
+			case RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
+				op.value = a.lt(b)
+			case RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
+				op.value = a.gt(b)
+			case RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
+				op.value = a.le(b)
+			case RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
+				op.value = a.ge(b)
+			}
+		}
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *ShiftExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case ShiftExpressionAdd: // AdditiveExpression
+		n.Operand = n.AdditiveExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.AdditiveExpression.IsSideEffectsFree
+	case ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
+		a := n.ShiftExpression.check(ctx, isAsmArg)
+		b := n.AdditiveExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.ShiftExpression.IsSideEffectsFree && n.AdditiveExpression.IsSideEffectsFree
+		if a.Type().Kind() == Vector || b.Type().Kind() == Vector {
+			n.Operand = checkBinaryVectorIntegerArtithmetic(ctx, n, a, b)
+			break
+		}
+
+		if !a.Type().IsIntegerType() || !b.Type().IsIntegerType() {
+			//TODO report err
+			break
+		}
+
+		a = a.integerPromotion(ctx, n)
+		b = b.integerPromotion(ctx, n)
+		n.promote = b.Type()
+		if a.Value() == nil || b.Value() == nil {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: a.Type()}
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: a.Value().lsh(b.Value())}).normalize(ctx, n)
+	case ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
+		a := n.ShiftExpression.check(ctx, isAsmArg)
+		b := n.AdditiveExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.ShiftExpression.IsSideEffectsFree && n.AdditiveExpression.IsSideEffectsFree
+		if a.Type().Kind() == Vector || b.Type().Kind() == Vector {
+			n.Operand = checkBinaryVectorIntegerArtithmetic(ctx, n, a, b)
+			break
+		}
+
+		if !a.Type().IsIntegerType() || !b.Type().IsIntegerType() {
+			//TODO report err
+			break
+		}
+
+		a = a.integerPromotion(ctx, n)
+		b = b.integerPromotion(ctx, n)
+		n.promote = b.Type()
+		if a.Value() == nil || b.Value() == nil {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: a.Type()}
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: a.Value().rsh(b.Value())}).normalize(ctx, n)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *AdditiveExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case AdditiveExpressionMul: // MultiplicativeExpression
+		n.Operand = n.MultiplicativeExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.MultiplicativeExpression.IsSideEffectsFree
+	case AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
+		n.promote = noType
+		a := n.AdditiveExpression.check(ctx, isAsmArg)
+		b := n.MultiplicativeExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.AdditiveExpression.IsSideEffectsFree && n.MultiplicativeExpression.IsSideEffectsFree
+		if a.Type().Kind() == Vector || b.Type().Kind() == Vector {
+			n.Operand = checkBinaryVectorArtithmetic(ctx, n, a, b)
+			break
+		}
+
+		if t := a.Type().Decay(); t.Kind() == Ptr && b.Type().IsScalarType() {
+			var x uintptr
+			hasx := false
+			switch v := b.Value().(type) {
+			case Int64Value:
+				x = uintptr(v)
+				hasx = true
+			case Uint64Value:
+				x = uintptr(v)
+				hasx = true
+			}
+			off := x * a.Type().Elem().Size()
+			switch y := a.Value().(type) {
+			case StringValue:
+				n.Operand = &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Ptr(n, a.Type().Elem()), value: y, offset: a.Offset() + off}
+			default:
+				switch {
+				case a.Value() == nil && a.Declarator() != nil && hasx:
+					n.Operand = &lvalue{Operand: &operand{abi: &ctx.cfg.ABI, typ: ctx.cfg.ABI.Ptr(n, a.Type().Elem()), offset: a.Offset() + off}, declarator: a.Declarator()}
+				default:
+					n.Operand = &operand{abi: &ctx.cfg.ABI, typ: t}
+				}
+			}
+			break
+		}
+
+		if t := b.Type().Decay(); t.Kind() == Ptr && a.Type().IsScalarType() {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: t}
+			break
+		}
+
+		if !a.Type().IsArithmeticType() || !b.Type().IsArithmeticType() {
+			//TODO report error
+			break
+		}
+
+		a, b = usualArithmeticConversions(ctx, &n.Token, a, b, true)
+		n.promote = a.Type()
+		if a.Value() == nil || b.Value() == nil {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: a.Type()}
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: a.Value().add(b.Value())}).normalize(ctx, n)
+	case AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
+		n.promote = noType
+		a := n.AdditiveExpression.check(ctx, isAsmArg)
+		b := n.MultiplicativeExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.AdditiveExpression.IsSideEffectsFree && n.MultiplicativeExpression.IsSideEffectsFree
+		if a.Type().Kind() == Vector || b.Type().Kind() == Vector {
+			n.Operand = checkBinaryVectorArtithmetic(ctx, n, a, b)
+			break
+		}
+
+		if a.Type().Decay().Kind() == Ptr && b.Type().Decay().Kind() == Ptr {
+			var val Value
+			if a.Value() != nil && b.Value() != nil {
+				ae := a.Type().Decay().Elem()
+				be := b.Type().Decay().Elem()
+				switch {
+				case ae.Size() == be.Size():
+					var d int64
+					switch x := a.Value().(type) {
+					case Int64Value:
+						d = int64(x)
+					case Uint64Value:
+						d = int64(x)
+					}
+					switch x := b.Value().(type) {
+					case Int64Value:
+						val = Int64Value(d - int64(x))
+					case Uint64Value:
+						val = Int64Value(d - int64(x))
+					}
+				default:
+					ctx.errNode(n, "difference of pointers of differently sized elements")
+				}
+			}
+			pt := ptrdiffT(ctx, n.lexicalScope, n.Token)
+			n.promote = pt
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: pt, value: val}
+			if val != nil {
+				n.Operand = n.Operand.convertTo(ctx, n, a.Type())
+			}
+			break
+		}
+
+		if t := a.Type().Decay(); t.Kind() == Ptr && b.Type().IsScalarType() {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: t}
+			break
+		}
+
+		if !a.Type().IsArithmeticType() || !b.Type().IsArithmeticType() {
+			//TODO report error
+			break
+		}
+
+		a, b = usualArithmeticConversions(ctx, &n.Token, a, b, true)
+		n.promote = a.Type()
+		if a.Value() == nil || b.Value() == nil {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: a.Type()}
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: a.Value().sub(b.Value())}).normalize(ctx, n)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func checkBinaryVectorArtithmetic(ctx *context, n Node, a, b Operand) Operand {
+	var rt Type
+	if a.Type().Kind() == Vector {
+		rt = a.Type()
+		a = &operand{abi: &ctx.cfg.ABI, typ: a.Type().Elem()}
+	}
+	if b.Type().Kind() == Vector {
+		if rt == nil {
+			rt = b.Type()
+		}
+		b = &operand{abi: &ctx.cfg.ABI, typ: b.Type().Elem()}
+	}
+	usualArithmeticConversions(ctx, n, a, b, true)
+	return &operand{abi: &ctx.cfg.ABI, typ: rt}
+}
+
+func ptrdiffT(ctx *context, s Scope, tok Token) Type {
+	if t := ctx.ptrdiffT; t != nil {
+		return t
+	}
+
+	t := ctx.stddef(idPtrdiffT, s, tok)
+	if t.Kind() != Invalid {
+		ctx.ptrdiffT = t
+	}
+	return t
+}
+
+func (n *MultiplicativeExpression) check(ctx *context, isAsmArg bool) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand //TODO-
+	switch n.Case {
+	case MultiplicativeExpressionCast: // CastExpression
+		n.Operand = n.CastExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.CastExpression.IsSideEffectsFree
+	case MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression
+		a := n.MultiplicativeExpression.check(ctx, isAsmArg)
+		b := n.CastExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.MultiplicativeExpression.IsSideEffectsFree && n.CastExpression.IsSideEffectsFree
+		if a.Type().Kind() == Vector || b.Type().Kind() == Vector {
+			n.Operand = checkBinaryVectorArtithmetic(ctx, n, a, b)
+			break
+		}
+
+		if !a.Type().IsArithmeticType() || !b.Type().IsArithmeticType() {
+			break
+		}
+
+		a, b = usualArithmeticConversions(ctx, &n.Token, a, b, true)
+		n.promote = a.Type()
+		if a.Value() == nil || b.Value() == nil {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: a.Type()}
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: a.Value().mul(b.Value())}).normalize(ctx, n)
+	case MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression
+		a := n.MultiplicativeExpression.check(ctx, isAsmArg)
+		b := n.CastExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.MultiplicativeExpression.IsSideEffectsFree && n.CastExpression.IsSideEffectsFree
+		if a.Type().Kind() == Vector || b.Type().Kind() == Vector {
+			n.Operand = checkBinaryVectorArtithmetic(ctx, n, a, b)
+			break
+		}
+
+		if !a.Type().IsArithmeticType() || !b.Type().IsArithmeticType() {
+			break
+		}
+
+		a, b = usualArithmeticConversions(ctx, &n.Token, a, b, true)
+		n.promote = a.Type()
+		if a.Value() == nil || b.Value() == nil {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: a.Type()}
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: a.Value().div(b.Value())}).normalize(ctx, n)
+	case MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
+		a := n.MultiplicativeExpression.check(ctx, isAsmArg)
+		b := n.CastExpression.check(ctx, isAsmArg)
+		n.IsSideEffectsFree = n.MultiplicativeExpression.IsSideEffectsFree && n.CastExpression.IsSideEffectsFree
+		if a.Type().Kind() == Vector || b.Type().Kind() == Vector {
+			n.Operand = checkBinaryVectorArtithmetic(ctx, n, a, b)
+			break
+		}
+
+		if !a.Type().IsArithmeticType() || !b.Type().IsArithmeticType() {
+			break
+		}
+
+		if !a.Type().IsIntegerType() || !b.Type().IsIntegerType() {
+			ctx.errNode(&n.Token, "the operands of the %% operator shall have integer type.") // [0] 6.5.5, 2
+			break
+		}
+
+		a, b = usualArithmeticConversions(ctx, &n.Token, a, b, true)
+		n.promote = a.Type()
+		if a.Value() == nil || b.Value() == nil {
+			n.Operand = &operand{abi: &ctx.cfg.ABI, typ: a.Type()}
+			break
+		}
+
+		n.Operand = (&operand{abi: &ctx.cfg.ABI, typ: a.Type(), value: a.Value().mod(b.Value())}).normalize(ctx, n)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *Declarator) check(ctx *context, td typeDescriptor, typ Type, tld bool) Type {
+	if n == nil {
+		n.typ = ctx.cfg.ABI.Type(Int)
+		return noType
+	}
+
+	typ = n.Pointer.check(ctx, typ)
+	n.td = td
+	if attr := n.AttributeSpecifierList.check(ctx, typ.baseP()); len(attr) != 0 {
+		typ = &attributedType{typ, attr}
+	}
+	n.typ = n.DirectDeclarator.check(ctx, typ)
+
+	hasStorageSpecifiers := td.typedef() || td.extern() || td.static() ||
+		td.auto() || td.register() || td.threadLocal()
+
+	typ = n.typ
+	if typ == nil {
+		n.typ = ctx.cfg.ABI.Type(Int)
+		ctx.errNode(n, "declarator has unsupported, invalid or incomplete type")
+		return noType
+	}
+
+	if typ.Kind() == Array && typ.IsVLA() {
+		if f := ctx.checkFn; f != nil {
+			f.VLAs = append(f.VLAs, n)
+		}
+	}
+
+	// 6.2.2 Linkages of identifiers
+	n.Linkage = None
+	switch {
+	case tld && td.static():
+		// 3: If the declaration of a file scope identifier for an object or a function
+		// contains the storage-class specifier static, the identifier has internal
+		// linkage.
+		n.Linkage = Internal
+	case td.extern():
+		//TODO
+		//
+		// 4: For an identifier declared with the storage-class specifier extern in a
+		// scope in which a prior declaration of that identifier is visible, 23) if the
+		// prior declaration specifies internal or external linkage, the linkage of the
+		// identifier at the later declaration is the same as the linkage specified at
+		// the prior declaration. If no prior declaration is visible, or if the prior
+		// declaration specifies no linkage, then the identifier has external linkage.
+		n.Linkage = External
+	case
+		!n.IsParameter && typ.Kind() == Function && !hasStorageSpecifiers,
+		tld && !hasStorageSpecifiers:
+
+		// 5: If the declaration of an identifier for a function has no storage-class
+		// specifier, its linkage is determined exactly as if it were declared with the
+		// storage-class specifier extern.
+		n.Linkage = External
+	}
+
+	// 6.2.4 Storage durations of objects
+	switch {
+	case n.Linkage == External, n.Linkage == Internal, td.static():
+		// 2: An object whose identifier is declared with external or internal linkage,
+		// or with the storage-class specifier static has static storage duration. Its
+		// lifetime is the entire execution of the program and its stored value is
+		// initialized only once, prior to
+		// program startup.
+		n.StorageClass = Static
+	case n.Linkage == None && !td.static():
+		// 4: An object whose identifier is declared with no linkage and without the
+		// storage-class specifier static has automatic storage duration.
+		n.StorageClass = Automatic
+	}
+	switch {
+	case n.typ.Kind() == Invalid:
+		ctx.errNode(n, "declarator has incomplete type")
+	}
+	if n.IsTypedefName {
+		if k, ok := complexTypedefs[n.Name()]; ok {
+			abi := ctx.cfg.ABI
+			t := n.typ.Alias()
+			t.setKind(k)
+			abi.types[k] = t
+			abi.Types[k] = ABIType{Size: t.Size(), Align: t.Align(), FieldAlign: t.FieldAlign()}
+		}
+	}
+	switch expr, ok := n.AttributeSpecifierList.Has(idVectorSize, idVectorSize2); {
+	case ok:
+		n.vectorize(ctx, expr)
+	default:
+		switch x := td.(type) {
+		case *DeclarationSpecifiers:
+			for ; x != nil; x = x.DeclarationSpecifiers {
+				if expr, ok := x.AttributeSpecifier.Has(idVectorSize, idVectorSize2); ok {
+					n.vectorize(ctx, expr)
+					break
+				}
+			}
+		}
+	}
+	return n.typ
+}
+
+func (n *Declarator) vectorize(ctx *context, expr *ExpressionList) {
+	dst := &n.typ
+	elem := n.typ
+	switch n.typ.Kind() {
+	case Function:
+		dst = &n.typ.(*functionType).result
+		elem = n.typ.Result()
+	}
+
+	sz := expr.vectorSize(ctx)
+	if sz == 0 {
+		sz = elem.Size()
+	}
+	if elem.Size() == 0 {
+		ctx.errNode(expr, "vector element has zero size")
+		return
+	}
+
+	if sz%elem.Size() != 0 {
+		ctx.errNode(expr, "vector size must be a multiple of the base size")
+	}
+	b := n.typ.base()
+	b.size = sz
+	b.kind = byte(Vector)
+	*dst = &vectorType{
+		typeBase: b,
+		elem:     elem,
+		length:   sz / elem.Size(),
+	}
+}
+
+func (n *ExpressionList) vectorSize(ctx *context) (r uintptr) {
+	if n.ExpressionList != nil {
+		ctx.errNode(n, "expected single expression")
+		return 0
+	}
+
+	switch x := n.AssignmentExpression.Operand.Value().(type) {
+	case Int64Value:
+		if x <= 0 {
+			ctx.errNode(n, "expected integer greater than zero")
+			return 0
+		}
+
+		r = uintptr(x)
+	case Uint64Value:
+		r = uintptr(x)
+	case nil:
+		ctx.errNode(n, "expected constant expression")
+		r = 0
+	default:
+		panic(todo("%T", x))
+	}
+	if bits.OnesCount64(uint64(r)) != 1 {
+		ctx.errNode(n, "expected a power of two")
+		r = 0
+	}
+	return r
+}
+
+func (n *DirectDeclarator) check(ctx *context, typ Type) Type {
+	if n == nil {
+		return noType
+	}
+
+	switch n.Case {
+	case DirectDeclaratorIdent: // IDENTIFIER Asm
+		n.Asm.check(ctx)
+		return typ
+	case DirectDeclaratorDecl: // '(' AttributeSpecifierList Declarator ')'
+		n.AttributeSpecifierList.check(ctx, typ.baseP())
+		return n.Declarator.check(ctx, noTypeDescriptor, typ, false)
+	case DirectDeclaratorArr: // DirectDeclarator '[' TypeQualifiers AssignmentExpression ']'
+		return n.DirectDeclarator.check(ctx, checkArray(ctx, &n.Token, typ, n.AssignmentExpression, true, false))
+	case DirectDeclaratorStaticArr: // DirectDeclarator '[' "static" TypeQualifiers AssignmentExpression ']'
+		return n.DirectDeclarator.check(ctx, checkArray(ctx, &n.Token, typ, n.AssignmentExpression, false, false))
+	case DirectDeclaratorArrStatic: // DirectDeclarator '[' TypeQualifiers "static" AssignmentExpression ']'
+		return n.DirectDeclarator.check(ctx, checkArray(ctx, &n.Token, typ, n.AssignmentExpression, false, false))
+	case DirectDeclaratorStar: // DirectDeclarator '[' TypeQualifiers '*' ']'
+		return n.DirectDeclarator.check(ctx, checkArray(ctx, &n.Token, typ, nil, true, true))
+	case DirectDeclaratorFuncParam: // DirectDeclarator '(' ParameterTypeList ')'
+		ft := &functionType{typeBase: typeBase{kind: byte(Function)}, result: typ}
+		if typ != nil && typ.Inline() {
+			ft.typeBase.flags = fInline
+		}
+		n.ParameterTypeList.check(ctx, ft)
+		return n.DirectDeclarator.check(ctx, ft)
+	case DirectDeclaratorFuncIdent: // DirectDeclarator '(' IdentifierList ')'
+		ft := &functionType{typeBase: typeBase{kind: byte(Function)}, result: typ, paramList: n.IdentifierList.check(ctx)}
+		if typ != nil && typ.Inline() {
+			ft.typeBase.flags = fInline
+		}
+		if n.idListNoDeclList {
+			n.checkIdentList(ctx, ft)
+		}
+		return n.DirectDeclarator.check(ctx, ft)
+	}
+
+	panic(internalErrorf("%v: %v", n.Position(), n.Case))
+}
+
+func (n *DirectDeclarator) checkIdentList(ctx *context, ft *functionType) {
+	s := n.paramScope
+	for _, nm := range ft.paramList {
+		d := s[nm][0].(*Declarator)
+		d.check(ctx, noTypeDescriptor, ctx.cfg.ABI.Type(Int), false)
+		ft.params = append(ft.params, &Parameter{d, d.Type()})
+	}
+}
+
+func checkArray(ctx *context, n Node, typ Type, expr *AssignmentExpression, exprIsOptional, noExpr bool) Type { //TODO pass and use typeQualifiers
+	if typ == nil {
+		ctx.errNode(n, "array of invalid or incomplete type")
+		return noType
+	}
+
+	b := typ.base()
+	b.align = byte(typ.Align())
+	b.fieldAlign = byte(typ.FieldAlign())
+	b.kind = byte(Array)
+	switch {
+	case expr != nil && noExpr:
+		panic(todo(""))
+	case expr != nil:
+		op := expr.check(ctx, false)
+		if op.Type().Kind() == Invalid {
+			return noType
+		}
+
+		if !op.Type().IsIntegerType() {
+			//TODO report err
+			return noType
+		}
+
+		var length uintptr
+		var vla bool
+		var vlaExpr *AssignmentExpression
+		switch x := op.Value().(type) {
+		case nil:
+			vla = true
+			vlaExpr = expr
+		case Int64Value:
+			length = uintptr(x)
+		case Uint64Value:
+			length = uintptr(x)
+		}
+		switch {
+		case vla:
+			b.size = ctx.cfg.ABI.Types[Ptr].Size
+		default:
+			if typ.IsIncomplete() {
+				//TODO report error
+				return noType
+			}
+
+			b.size = length * typ.Size()
+		}
+		return &arrayType{typeBase: b, decay: ctx.cfg.ABI.Ptr(n, typ), elem: typ, length: length, vla: vla, expr: vlaExpr}
+	case noExpr:
+		// nop
+	case !exprIsOptional:
+		panic(todo(""))
+	}
+	b.flags |= fIncomplete
+	return &arrayType{typeBase: b, decay: ctx.cfg.ABI.Ptr(n, typ), elem: typ}
+}
+
+func (n *IdentifierList) check(ctx *context) (r []StringID) {
+	for ; n != nil; n = n.IdentifierList {
+		tok := n.Token2.Value
+		if tok == 0 {
+			tok = n.Token.Value
+		}
+		r = append(r, tok)
+	}
+	return r
+}
+
+func (n *Asm) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	n.AsmQualifierList.check(ctx)
+	n.AsmArgList.check(ctx)
+}
+
+func (n *AsmArgList) check(ctx *context) {
+	for ; n != nil; n = n.AsmArgList {
+		n.AsmExpressionList.check(ctx)
+	}
+}
+
+func (n *AsmExpressionList) check(ctx *context) {
+	if ctx.cfg.DoNotTypecheckAsm {
+		return
+	}
+
+	for ; n != nil; n = n.AsmExpressionList {
+		n.AsmIndex.check(ctx)
+		n.AssignmentExpression.check(ctx, true)
+	}
+}
+
+func (n *AsmIndex) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	n.Expression.check(ctx, true)
+}
+
+func (n *AsmQualifierList) check(ctx *context) {
+	for ; n != nil; n = n.AsmQualifierList {
+		n.AsmQualifier.check(ctx)
+	}
+}
+
+func (n *AsmQualifier) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case AsmQualifierVolatile: // "volatile"
+		//TODO
+	case AsmQualifierInline: // "inline"
+		//TODO
+	case AsmQualifierGoto: // "goto"
+		//TODO
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *AttributeSpecifierList) check(ctx *context, t *typeBase) (a []*AttributeSpecifier) {
+	for ; n != nil; n = n.AttributeSpecifierList {
+		a = append(a, n.AttributeSpecifier.check(ctx, t))
+	}
+	return a
+}
+
+func (n *AttributeSpecifier) check(ctx *context, t *typeBase) *AttributeSpecifier {
+	if n == nil {
+		return nil
+	}
+
+	n.AttributeValueList.check(ctx, t)
+	return n
+}
+
+func (n *AttributeValueList) check(ctx *context, t *typeBase) {
+	for ; n != nil; n = n.AttributeValueList {
+		n.AttributeValue.check(ctx, t)
+	}
+}
+
+func (n *AttributeValue) check(ctx *context, t *typeBase) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case AttributeValueIdent: // IDENTIFIER
+		if n.Token.Value == idPacked && t != nil {
+			t.flags |= fPacked
+		}
+	case AttributeValueExpr: // IDENTIFIER '(' ExpressionList ')'
+		v := ctx.cfg.ignoreErrors
+		ctx.cfg.ignoreErrors = true
+		defer func() { ctx.cfg.ignoreErrors = v }()
+		n.ExpressionList.check(ctx, false)
+		if n.Token.Value == idAligned && n.ExpressionList != nil && t != nil {
+			switch x := n.ExpressionList.AssignmentExpression.Operand.Value().(type) {
+			case Int64Value:
+				t.setAligned(int(x))
+				switch t.Kind() {
+				case Struct, Union:
+					ctx.structs[StructInfo{Size: t.Size(), Align: t.Align()}] = struct{}{}
+				}
+			}
+		}
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *ExpressionList) check(ctx *context, isAsmArg bool) {
+	for ; n != nil; n = n.ExpressionList {
+		n.AssignmentExpression.check(ctx, isAsmArg)
+	}
+}
+
+func (n *DeclarationSpecifiers) check(ctx *context, inUnion bool) (r Type, inline, noret bool) {
+	n0 := n
+	typ := &typeBase{}
+	for ; n != nil; n = n.DeclarationSpecifiers {
+		switch n.Case {
+		case DeclarationSpecifiersStorage: // StorageClassSpecifier DeclarationSpecifiers
+			n.StorageClassSpecifier.check(ctx, n)
+		case DeclarationSpecifiersTypeSpec: // TypeSpecifier DeclarationSpecifiers
+			n.TypeSpecifier.check(ctx, typ, inUnion)
+		case DeclarationSpecifiersTypeQual: // TypeQualifier DeclarationSpecifiers
+			n.TypeQualifier.check(ctx, typ)
+		case DeclarationSpecifiersFunc: // FunctionSpecifier DeclarationSpecifiers
+			if n.FunctionSpecifier == nil {
+				break
+			}
+
+			switch n.FunctionSpecifier.Case {
+			case FunctionSpecifierInline: // "inline"
+				inline = true
+			case FunctionSpecifierNoreturn: // "_Noreturn"
+				noret = true
+			default:
+				panic(todo(""))
+			}
+		case DeclarationSpecifiersAlignSpec: // AlignmentSpecifier DeclarationSpecifiers
+			n.AlignmentSpecifier.check(ctx)
+		case DeclarationSpecifiersAttribute: // AttributeSpecifier DeclarationSpecifiers
+			n.AttributeSpecifier.check(ctx, typ)
+		default:
+			panic(todo(""))
+		}
+	}
+	r = typ.check(ctx, n0, true)
+	return r, inline, noret
+}
+
+func (n *AlignmentSpecifier) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case AlignmentSpecifierAlignasType: // "_Alignas" '(' TypeName ')'
+		n.TypeName.check(ctx, false, false, nil)
+		//TODO actually set the alignment
+	case AlignmentSpecifierAlignasExpr: // "_Alignas" '(' ConstantExpression ')'
+		n.ConstantExpression.check(ctx, ctx.mode|mIntConstExpr, false)
+		//TODO actually set the alignment
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *StorageClassSpecifier) check(ctx *context, ds *DeclarationSpecifiers) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case StorageClassSpecifierTypedef: // "typedef"
+		ds.class |= fTypedef
+	case StorageClassSpecifierExtern: // "extern"
+		ds.class |= fExtern
+	case StorageClassSpecifierStatic: // "static"
+		ds.class |= fStatic
+	case StorageClassSpecifierAuto: // "auto"
+		ds.class |= fAuto
+	case StorageClassSpecifierRegister: // "register"
+		ds.class |= fRegister
+	case StorageClassSpecifierThreadLocal: // "_Thread_local"
+		ds.class |= fThreadLocal
+	default:
+		panic(todo(""))
+	}
+	c := bits.OnesCount(uint(ds.class & (fTypedef | fExtern | fStatic | fAuto | fRegister | fThreadLocal)))
+	if c == 1 {
+		return
+	}
+
+	// [2], 6.7.1, 2
+	if c == 2 && ds.class&fThreadLocal != 0 {
+		if ds.class&(fStatic|fExtern) != 0 {
+			return
+		}
+	}
+
+	ctx.errNode(n, "at most, one storage-class specifier may be given in the declaration specifiers in a declaration")
+}
+
+// DeclarationSpecifiers Declarator DeclarationList CompoundStatement
+func (n *FunctionDefinition) checkDeclarator(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	n.Declarator.fnDef = true
+	n.Declarator.funcDefinition = n
+	ctx.checkFn = n
+	typ, inline, noret := n.DeclarationSpecifiers.check(ctx, false)
+	typ = n.Declarator.check(ctx, n.DeclarationSpecifiers, typ, true)
+	typ.setFnSpecs(inline, noret)
+	ctx.checkFn = nil
+	n.DeclarationList.checkFn(ctx, typ, n.Declarator.ParamScope())
+}
+
+func (n *DeclarationList) checkFn(ctx *context, typ Type, s Scope) {
+	if n == nil {
+		return
+	}
+
+	n.check(ctx)
+	ft, ok := typ.(*functionType)
+	if !ok {
+		return
+	}
+
+	if ft.params != nil {
+		//TODO report error
+		return
+	}
+
+	if len(ft.paramList) == 0 {
+		//TODO report error
+		return
+	}
+
+	m := make(map[StringID]int, len(ft.paramList))
+	for i, v := range ft.paramList {
+		if _, ok := m[v]; ok {
+			ctx.errNode(n, "duplicate parameter: %s", v)
+			continue
+		}
+
+		m[v] = i
+	}
+	params := make([]*Parameter, len(m))
+	i := 0
+	for ; n != nil; n = n.DeclarationList {
+		for n := n.Declaration.InitDeclaratorList; n != nil; n = n.InitDeclaratorList {
+			n := n.InitDeclarator
+			switch n.Case {
+			case InitDeclaratorDecl: // Declarator AttributeSpecifierList
+				nm := n.Declarator.Name()
+				n.Declarator.IsParameter = true
+				switch x, ok := m[nm]; {
+				case ok:
+					params[x] = &Parameter{d: n.Declarator, typ: n.Declarator.Type()}
+					i++
+				default:
+					//TODO report error
+				}
+			case InitDeclaratorInit: // Declarator AttributeSpecifierList '=' Initializer
+				//TODO report error
+				return
+			default:
+				panic(todo(""))
+			}
+		}
+	}
+	for i, v := range params {
+		if v != nil {
+			continue
+		}
+
+		nm := ft.paramList[i]
+		d := &Declarator{
+			DirectDeclarator: &DirectDeclarator{
+				Case:  DirectDeclaratorIdent,
+				Token: Token{Rune: IDENTIFIER, Value: nm},
+			},
+			IsParameter:  true,
+			Linkage:      None,
+			StorageClass: Automatic,
+			typ:          ctx.cfg.ABI.Type(Int),
+		}
+		s.declare(nm, d)
+		params[i] = &Parameter{d, d.typ}
+	}
+	ft.params = params
+}
+
+func (n *CompoundStatement) check(ctx *context) Operand {
+	n.Operand = n.BlockItemList.check(ctx)
+	return n.Operand
+}
+
+func (n *BlockItemList) check(ctx *context) (r Operand) {
+	r = noOperand
+	var last *BlockItem
+	for ; n != nil; n = n.BlockItemList {
+		last = n.BlockItem
+		r = n.BlockItem.check(ctx)
+	}
+	if last != nil {
+		last.Last = true
+	}
+	return r
+}
+
+func (n *BlockItem) check(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	switch n.Case {
+	case BlockItemDecl: // Declaration
+		n.Declaration.check(ctx, false)
+	case BlockItemStmt: // Statement
+		return n.Statement.check(ctx)
+	case BlockItemLabel: // LabelDeclaration
+		n.LabelDeclaration.check(ctx)
+	case BlockItemFuncDef: // DeclarationSpecifiers Declarator CompoundStatement
+		ctxClosure := ctx.closure
+		ctx.closure = nil
+		ctxCheckFn := ctx.checkFn
+		fn := &FunctionDefinition{
+			DeclarationSpecifiers: n.DeclarationSpecifiers,
+			Declarator:            n.Declarator,
+			CompoundStatement:     n.CompoundStatement,
+		}
+		n.fn = fn
+		ctx.checkFn = fn
+		n.CompoundStatement.scope.declare(idClosure, n)
+		fn.checkDeclarator(ctx)
+		ctxCapture := ctx.capture
+		ctx.capture = true
+		fn.checkBody(ctx)
+		n.closure = ctx.closure
+		ctx.capture = ctxCapture
+		delete(n.CompoundStatement.scope, idClosure)
+		ctx.checkFn = ctxCheckFn
+		ctx.closure = ctxClosure
+	case BlockItemPragma: // PragmaSTDC
+		n.PragmaSTDC.check(ctx)
+	default:
+		panic(todo(""))
+	}
+	return noOperand
+}
+
+func (n *LabelDeclaration) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	n.IdentifierList.check(ctx)
+}
+
+func (n *Statement) check(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.Operand = noOperand
+	switch n.Case {
+	case StatementLabeled: // LabeledStatement
+		n.LabeledStatement.check(ctx)
+	case StatementCompound: // CompoundStatement
+		n.Operand = n.CompoundStatement.check(ctx)
+	case StatementExpr: // ExpressionStatement
+		n.Operand = n.ExpressionStatement.check(ctx)
+	case StatementSelection: // SelectionStatement
+		n.SelectionStatement.check(ctx)
+	case StatementIteration: // IterationStatement
+		n.IterationStatement.check(ctx)
+	case StatementJump: // JumpStatement
+		n.JumpStatement.check(ctx)
+	case StatementAsm: // AsmStatement
+		n.AsmStatement.check(ctx)
+	default:
+		panic(todo(""))
+	}
+	return n.Operand
+}
+
+func (n *JumpStatement) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case JumpStatementGoto: // "goto" IDENTIFIER ';'
+		n.context = ctx.breakCtx
+		if ctx.checkFn.Gotos == nil {
+			ctx.checkFn.Gotos = map[StringID]*JumpStatement{}
+		}
+		ctx.checkFn.Gotos[n.Token2.Value] = n
+	case JumpStatementGotoExpr: // "goto" '*' Expression ';'
+		n.Expression.check(ctx, false)
+		//TODO
+	case JumpStatementContinue: // "continue" ';'
+		n.context = ctx.breakCtx
+		if ctx.continues <= 0 {
+			panic(n.Position().String())
+		}
+		//TODO
+	case JumpStatementBreak: // "break" ';'
+		n.context = ctx.breakCtx
+		if ctx.breaks <= 0 {
+			panic(n.Position().String())
+		}
+		//TODO
+	case JumpStatementReturn: // "return" Expression ';'
+		n.context = ctx.breakCtx
+		op := n.Expression.check(ctx, false)
+		if op.Type().IsComplexType() {
+			ctx.checkFn.ReturnComplexExpr = append(ctx.checkFn.ReturnComplexExpr, n.Expression)
+		}
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *IterationStatement) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	sv := ctx.breakCtx
+	ctx.breakCtx = n
+
+	defer func() { ctx.breakCtx = sv }()
+
+	switch n.Case {
+	case IterationStatementWhile: // "while" '(' Expression ')' Statement
+		n.Expression.check(ctx, false)
+		ctx.breaks++
+		ctx.continues++
+		n.Statement.check(ctx)
+		ctx.breaks--
+		ctx.continues--
+	case IterationStatementDo: // "do" Statement "while" '(' Expression ')' ';'
+		ctx.breaks++
+		ctx.continues++
+		n.Statement.check(ctx)
+		ctx.breaks--
+		ctx.continues--
+		n.Expression.check(ctx, false)
+	case IterationStatementFor: // "for" '(' Expression ';' Expression ';' Expression ')' Statement
+		n.Expression.check(ctx, false)
+		n.Expression2.check(ctx, false)
+		n.Expression3.check(ctx, false)
+		ctx.breaks++
+		ctx.continues++
+		n.Statement.check(ctx)
+		ctx.breaks--
+		ctx.continues--
+	case IterationStatementForDecl: // "for" '(' Declaration Expression ';' Expression ')' Statement
+		n.Declaration.check(ctx, false)
+		n.Expression.check(ctx, false)
+		n.Expression2.check(ctx, false)
+		ctx.breaks++
+		ctx.continues++
+		n.Statement.check(ctx)
+		ctx.breaks--
+		ctx.continues--
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *SelectionStatement) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case SelectionStatementIf: // "if" '(' Expression ')' Statement
+		n.Expression.check(ctx, false)
+		n.Statement.check(ctx)
+	case SelectionStatementIfElse: // "if" '(' Expression ')' Statement "else" Statement
+		n.Expression.check(ctx, false)
+		n.Statement.check(ctx)
+		n.Statement2.check(ctx)
+		if !n.Expression.Operand.Type().IsScalarType() {
+			//TODO report err
+			break
+		}
+	case SelectionStatementSwitch: // "switch" '(' Expression ')' Statement
+		if n == nil {
+			return
+		}
+
+		sv := ctx.breakCtx
+		ctx.breakCtx = n
+
+		defer func() { ctx.breakCtx = sv }()
+
+		op := n.Expression.check(ctx, false)
+		n.promote = op.integerPromotion(ctx, n).Type()
+		cp := ctx.casePromote
+		ctx.casePromote = n.promote
+		cs := ctx.cases
+		ctx.cases = nil
+		ctx.switches++
+		ctx.breaks++
+		n.Statement.check(ctx)
+		ctx.breaks--
+		ctx.switches--
+		n.cases = ctx.cases
+		ctx.cases = cs
+		ctx.casePromote = cp
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *ExpressionStatement) check(ctx *context) Operand {
+	if n == nil {
+		return noOperand
+	}
+
+	n.AttributeSpecifierList.check(ctx, nil)
+	return n.Expression.check(ctx, false)
+}
+
+func (n *LabeledStatement) check(ctx *context) {
+	if n == nil {
+		return
+	}
+
+	switch n.Case {
+	case LabeledStatementLabel: // IDENTIFIER ':' AttributeSpecifierList Statement
+		if ctx.checkFn.Labels == nil {
+			ctx.checkFn.Labels = map[StringID]*LabeledStatement{}
+		}
+		if _, ok := ctx.checkFn.Labels[n.Token.Value]; ok {
+			//TODO report redeclared
+		}
+		ctx.checkFn.Labels[n.Token.Value] = n
+		n.AttributeSpecifierList.check(ctx, nil)
+		n.Statement.check(ctx)
+	case LabeledStatementCaseLabel: // "case" ConstantExpression ':' Statement
+		if ctx.switches <= 0 {
+			//TODO report error
+			break
+		}
+
+		switch op := n.ConstantExpression.check(ctx, ctx.mode|mIntConstExpr, false); op.Value().(type) {
+		case Int64Value, Uint64Value:
+			if t := ctx.casePromote; t.Kind() != Invalid {
+				n.ConstantExpression.Operand = op.convertTo(ctx, n, t)
+				break
+			}
+
+			//TODO report error
+		default:
+			//TODO report error
+		}
+		ctx.cases = append(ctx.cases, n)
+		n.Statement.check(ctx)
+	case LabeledStatementRange: // "case" ConstantExpression "..." ConstantExpression ':' Statement
+		if ctx.switches <= 0 {
+			//TODO report error
+			break
+		}
+
+		switch n.ConstantExpression.check(ctx, ctx.mode|mIntConstExpr, false).Value().(type) {
+		case Int64Value, Uint64Value:
+			// ok
+		default:
+			//TODO report error
+		}
+		switch n.ConstantExpression2.check(ctx, ctx.mode|mIntConstExpr, false).Value().(type) {
+		case Int64Value, Uint64Value:
+			// ok
+		default:
+			//TODO report error
+		}
+		ctx.cases = append(ctx.cases, n)
+		n.Statement.check(ctx)
+	case LabeledStatementDefault: // "default" ':' Statement
+		if ctx.switches <= 0 {
+			//TODO report error
+			break
+		}
+
+		ctx.cases = append(ctx.cases, n)
+		n.Statement.check(ctx)
+	default:
+		panic(todo(""))
+	}
+}
+
+func (n *DeclarationList) check(ctx *context) {
+	for ; n != nil; n = n.DeclarationList {
+		n.Declaration.check(ctx, false)
+	}
+}
+
+func setAddressTaken(n Node, d *Declarator, s string) {
+	d.AddressTaken = true
+	// fmt.Printf("%v: %s, type %v (%v, %v), declared at %v, AddressTaken = true: %v\n",
+	// 	n.Position(), d.Name(), d.Type(), d.Type().Kind(), d.Type().Size(), d.Position(), s,
+	// ) //TODO-
+}
+
+// Dump returns a debug form of n.
+func (n *Initializer) Dump() string {
+	var b strings.Builder
+	f := strutil.IndentFormatter(&b, "\t")
+	n.dump(f)
+	return b.String()
+}
+
+func pos(n Node) (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	r = token.Position(n.Position())
+	if r.IsValid() {
+		r.Filename = filepath.Base(r.Filename)
+	}
+	return r
+}
+
+func (n *Initializer) dump(f strutil.Formatter) {
+	list := n.List()
+	if len(list) != 0 {
+		for i, v := range list {
+			f.Format("Initializer.List() #%d/%d: %v: off %v type %v", i, len(list), pos(v), v.Offset, v.Type())
+			if fld := v.FirstDesignatorField(); fld != nil {
+				f.Format(" [FirstDesignatorField %q]", fld.Name())
+			}
+			f.Format("\n")
+		}
+	}
+	if f0 := n.FirstDesignatorField(); f0 != nil {
+		f.Format("[FirstDesignatorField: %q, index %v, off %v, type %v] ", f0.Name(), f0.Index(), n.Offset, n.Type().Alias())
+	}
+	switch n.Case {
+	case InitializerExpr: // AssignmentExpression
+		if op := n.AssignmentExpression.Operand; op != nil {
+			n.isConst = op.IsConst()
+			n.isZero = op.IsZero()
+		}
+		var t Type
+		if n.AssignmentExpression != nil && n.AssignmentExpression.Operand != nil {
+			t = n.AssignmentExpression.Operand.Type()
+		}
+		f.Format("%v: %T@%[2]p, .Case %v, off %v,  type %v\n", pos(n), n, n.Case, n.Offset, t.Alias())
+	case InitializerInitList: // '{' InitializerList ',' '}'
+		n.InitializerList.dump(f)
+	default:
+		panic(todo("%v:", n.Position()))
+	}
+}
+
+// Dump returns a debug form of n.
+func (n *InitializerList) Dump() string {
+	var b strings.Builder
+	f := strutil.IndentFormatter(&b, "\t")
+	n.dump(f)
+	return b.String()
+}
+
+func (n *InitializerList) dump(f strutil.Formatter) {
+	if n == nil {
+		f.Format("<nil>")
+		return
+	}
+
+	f.Format("%v: %T@%[2]p, len(.List()) %v {%i\n", pos(n), n, len(n.List()))
+	list := n.List()
+	for ; n != nil; n = n.InitializerList {
+		n.Designation.dump(f)
+		n.Initializer.dump(f)
+	}
+	for i, v := range list {
+		f.Format("InitializerList.List() #%d/%d:", i, len(list))
+		v.dump(f)
+	}
+	f.Format("%u}\n")
+}
+
+func (n *Designation) dump(f strutil.Formatter) {
+	if n == nil {
+		return
+	}
+
+	cnt := 0
+	designatorField2 := false
+	for n := n.DesignatorList; n != nil; n = n.DesignatorList {
+		n.Designator.dump(f)
+		if n.Designator.Case == DesignatorField2 {
+			designatorField2 = true
+		}
+		cnt++
+	}
+	if cnt > 1 || !designatorField2 {
+		f.Format(" = ")
+	}
+}
+
+func (n *Designator) dump(f strutil.Formatter) {
+	switch n.Case {
+	case DesignatorIndex: // '[' ConstantExpression ']'
+		f.Format("[%v]", n.ConstantExpression.Operand.Value())
+	case DesignatorField: // '.' IDENTIFIER
+		f.Format(".%s", n.Token2.Value)
+	case DesignatorField2: // IDENTIFIER ':'
+		f.Format("%s:", n.Token.Value)
+	default:
+		panic(todo(""))
+	}
+}