// NewCharArray returns a character array constant based on the given array type
// and string.
func NewCharArray(typ types.Type, s string) (*Array, error) {
	// Verify array type.
	v := new(Array)
	var ok bool
	v.typ, ok = typ.(*types.Array)
	if !ok {
		return nil, fmt.Errorf("invalid type %q for array constant", typ)
	}
	var err error
	s, err = unquote(s)
	if err != nil {
		return nil, errutil.Err(err)
	}

	// Verify array element types.
	if len(s) != v.typ.Len() {
		return nil, fmt.Errorf("incorrect number of elements in character array constant; expected %d, got %d", v.typ.Len(), len(s))
	}
	elemType := v.typ.Elem()
	if !types.Equal(elemType, types.I8) {
		return nil, fmt.Errorf("invalid character array element type; expected %q, got %q", types.I8, elemType)
	}
	for i := 0; i < len(s); i++ {
		elem, err := NewInt(elemType, strconv.Itoa(int(s[i])))
		if err != nil {
			return nil, errutil.Err(err)
		}
		v.elems = append(v.elems, elem)
	}

	return v, nil
}

// NewGetElementPtrInst returns a new getelementptr instruction based on the
// given element type, address and element indices.
func NewGetElementPtrInst(elem, srcAddrType, srcAddr, elemIndices interface{}) (*instruction.GetElementPtr, error) {
	if elem, ok := elem.(types.Type); ok {
		srcAddr, err := NewValue(srcAddrType, srcAddr)
		if err != nil {
			return nil, errutil.Err(err)
		}
		var indices []value.Value
		switch elemIndices := elemIndices.(type) {
		case []value.Value:
			indices = elemIndices
		case nil:
		default:
			panic(fmt.Sprintf("support for element indices type %T not yet implemented", elemIndices))
		}
		// Validate that elem is of identical type as the element type of srcAddr.
		srcAddrType, ok := srcAddr.Type().(*types.Pointer)
		if !ok {
			return nil, errutil.Newf("invalid source address pointer type; expected *types.Pointer, got %T", srcAddr.Type())
		}
		if !types.Equal(elem, srcAddrType.Elem()) {
			return nil, errutil.Newf("type mismatch between element type (%v) and source address element type (%v)", elem, srcAddrType.Elem())
		}
		return instruction.NewGetElementPtr(srcAddr, indices)
	}
	return nil, errutil.Newf("invalid operand type; expected types.Type, got %T", elem)
}

// convert converts the given value to the specified type, emitting code to f.
// No conversion is made, if v is already of the correct type.
func (m *Module) convert(f *Function, v value.Value, to irtypes.Type) value.Value {
	// Early return if v is already of the correct type.
	from := v.Type()
	if irtypes.Equal(from, to) {
		return v
	}
	fromType, ok := from.(*irtypes.Int)
	if !ok {
		panic(fmt.Sprintf("support for converting from type %T not yet implemented", from))
	}
	toType, ok := to.(*irtypes.Int)
	if !ok {
		panic(fmt.Sprintf("support for converting to type %T not yet implemented", to))
	}

	// Convert constant values.
	if v, ok := v.(constant.Constant); ok {
		switch v := v.(type) {
		case *constant.Int:
			v, err := constant.NewInt(toType, v.ValueString())
			if err != nil {
				panic(fmt.Sprintf("unable to create integer constant; %v", err))
			}
			return v
		default:
			panic(fmt.Sprintf("support for converting type %T not yet implemented", v))
		}
	}

	// TODO: Add proper support for converting signed and unsigned values, using
	// sext and zext, respectively.

	// Convert unsigned values.
	if irtypes.IsBool(fromType) {
		// Zero extend boolean values.
		zextInst, err := instruction.NewZExt(v, toType)
		if err != nil {
			panic(fmt.Sprintf("unable to create sext instruction; %v", err))
		}
		return f.emitInst(zextInst)
	}

	// Convert signed values.
	if toType.Size() > fromType.Size() {
		// Sign extend.
		sextInst, err := instruction.NewSExt(v, toType)
		if err != nil {
			panic(fmt.Sprintf("unable to create sext instruction; %v", err))
		}
		return f.emitInst(sextInst)
	}
	// Truncate.
	truncInst, err := instruction.NewTrunc(v, toType)
	if err != nil {
		panic(fmt.Sprintf("unable to create trunc instruction; %v", err))
	}
	return f.emitInst(truncInst)
}

// NewBr returns a new conditional branch instruction based on the given
// branching condition, and the true and false target branches.
func NewBr(cond value.Value, trueBranch, falseBranch value.NamedValue) (*Br, error) {
	// TODO: Validate that trueBranch and falseBranch are of type *ir.BasicBlock.
	// Better yet, chance the signature of NewBr to enforce this. Another
	// approach, is to simply check that the type of trueBranch and falseBranch
	// are both "label".
	if !types.Equal(cond.Type(), types.I1) {
		return nil, errutil.Newf("conditional type mismatch; expected i1, got %v", cond.Type())
	}
	return &Br{cond: cond, trueBranch: trueBranch, falseBranch: falseBranch}, nil
}

// NewSelect returns a new select instruction based on the given selection
// condition, and operands.
//
// Pre-condition: cond is of boolean or boolean vector type. x and y are of
// identical types.
func NewSelect(cond, x, y value.Value) (*Select, error) {
	// Validate that cond is of boolean or boolean vector type.
	if !types.IsBools(cond.Type()) {
		return nil, errutil.Newf("invalid selection condition type; expected boolean or boolean vector, got %v", cond.Type())
	}
	// Validate that x and y are of identical types.
	if !types.Equal(x.Type(), y.Type()) {
		return nil, errutil.Newf("type mismatch between x (%v) and y (%v)", x.Type(), y.Type())
	}
	return &Select{cond: cond, x: x, y: y}, nil
}

// indexExpr lowers the given index expression to LLVM IR, emitting code to f.
func (m *Module) indexExpr(f *Function, n *ast.IndexExpr) value.Value {
	index := m.expr(f, n.Index)
	// Extend the index to a 64-bit integer.
	if !irtypes.Equal(index.Type(), irtypes.I64) {
		index = m.convert(f, index, irtypes.I64)
	}
	typ := m.typeOf(n.Name)
	array := m.valueFromIdent(f, n.Name)

	// Dereference pointer pointer.
	elem := typ
	addr := array
	zero := constZero(irtypes.I64)
	indices := []value.Value{zero, index}
	if typ, ok := typ.(*irtypes.Pointer); ok {
		elem = typ.Elem()

		// Emit load instruction.
		// TODO: Validate typ against array.Elem().
		loadInst, err := instruction.NewLoad(array)
		if err != nil {
			panic(fmt.Sprintf("unable to create load instruction; %v", err))
		}
		addr = f.emitInst(loadInst)
		indices = []value.Value{index}
	}

	// Emit getelementptr instruction.
	if m.isGlobal(n.Name) {
		var is []constant.Constant
		for _, index := range indices {
			i, ok := index.(constant.Constant)
			if !ok {
				break
			}
			is = append(is, i)
		}
		if len(is) == len(indices) {
			// In accordance with Clang, emit getelementptr constant expressions
			// for global variables.
			gepExpr, err := constant.NewGetElementPtr(elem, addr, is)
			if err != nil {
				panic(fmt.Sprintf("unable to create getelementptr expression; %v", err))
			}
			return gepExpr
		}
	}
	// TODO: Validate elem against array.Elem().
	gepInst, err := instruction.NewGetElementPtr(addr, indices)
	if err != nil {
		panic(fmt.Sprintf("unable to create getelementptr instruction; %v", err))
	}
	return f.emitInst(gepInst)
}

// NewStore returns a new store instruction based on the given source value and
// destination address.
//
// Pre-condition:
//    1. dstAddr is of pointer type
//    2. src is of identical type as the element type of dstAddr
func NewStore(src, dstAddr value.Value) (*Store, error) {
	// Validate that dstAddr is of pointer type.
	dstAddrType, ok := dstAddr.Type().(*types.Pointer)
	if !ok {
		return nil, errutil.Newf("invalid destination address pointer type; expected *types.Pointer, got %T", dstAddr.Type())
	}
	// Validate that src is of identical type as the element type of dstAddr.
	if !types.Equal(src.Type(), dstAddrType.Elem()) {
		return nil, errutil.Newf("type mismatch between source value (%v) and destination address element type (%v)", src.Type(), dstAddrType.Elem())
	}
	return &Store{src: src, dstAddr: dstAddr}, nil
}

// NewICmp returns a new icmp instruction based on the given condition and
// operands.
//
// Pre-condition: x and y are of identical types. x and y are of integer,
// integer vector, pointer or pointer vector type.
func NewICmp(cond ICond, x, y value.Value) (*ICmp, error) {
	// Validate that x and y are of identical types.
	if !types.Equal(x.Type(), y.Type()) {
		return nil, errutil.Newf("type mismatch between x (%v) and y (%v)", x.Type(), y.Type())
	}
	// Validate that x and y are of integer, integer vector, pointer or pointer
	// vector type.
	if !types.IsInts(x.Type()) && !types.IsPointers(x.Type()) {
		return nil, errutil.Newf("invalid x operand type; expected integer, integer vector, pointer or pointer vector, got %v", x.Type())
	}
	if !types.IsInts(y.Type()) && !types.IsPointers(y.Type()) {
		return nil, errutil.Newf("invalid y operand type; expected integer, integer vector, pointer or pointer vector, got %v", y.Type())
	}
	return &ICmp{cond: cond, x: x, y: y}, nil
}

// NewPHI returns a new phi instruction based on the given incoming values.
//
// Pre-condition: incs is non-empty and each incoming value is of identical
// type.
func NewPHI(incs []*Incoming) (*PHI, error) {
	// Validate that incs is non-empty.
	if len(incs) < 1 {
		return nil, errutil.Newf("invalid number of incoming values; expected > 0, got %d", len(incs))
	}
	// Validate that each incoming value is of identical type.
	a := incs[0].val.Type()
	for i := 1; i < len(incs); i++ {
		b := incs[i].val.Type()
		if !types.Equal(a, b) {
			return nil, errutil.Newf("type mismatch between incoming value 0 (%v) and %d (%v)", a, i, b)
		}
	}
	return &PHI{incs: incs}, nil
}

// NewLoadInst returns a new load instruction based on the given type and
// address.
func NewLoadInst(typ, srcAddrType, srcAddr interface{}) (*instruction.Load, error) {
	if typ, ok := typ.(types.Type); ok {
		srcAddr, err := NewValue(srcAddrType, srcAddr)
		if err != nil {
			return nil, errutil.Err(err)
		}
		srcAddrType, ok := srcAddr.Type().(*types.Pointer)
		if !ok {
			return nil, errutil.Newf("invalid source address pointer type; expected *types.Pointer, got %T", srcAddr.Type())
		}
		if !types.Equal(typ, srcAddrType.Elem()) {
			return nil, errutil.Newf("type mismatch between element type (%v) and source address element type (%v)", typ, srcAddrType.Elem())
		}
		return instruction.NewLoad(srcAddr)
	}
	return nil, errutil.Newf("invalid operand type; expected types.Type, got %T", typ)
}

// NewGetElementPtr returns a new getelementptr expression based on the given
// element type, address and element indices.
//
// Preconditions:
//    * elem is of the same type as addr.Type().Elem().
//    * addr is of pointer type.
//    * indices used to index structure fields are integer constants.
func NewGetElementPtr(elem types.Type, addr value.Value, indices []Constant) (*GetElementPtr, error) {
	// Sanity checks.
	addrType, ok := addr.Type().(*types.Pointer)
	if !ok {
		return nil, errutil.Newf("invalid pointer type; expected *types.Pointer, got %T", addr.Type())
	}
	if !types.Equal(elem, addrType.Elem()) {
		return nil, errutil.Newf("type mismatch between %v and %v", elem, addrType.Elem())
	}

	e := addrType.Elem()
	for i, index := range indices {
		if i == 0 {
			// Ignore checking the 0th index as it simply follows the pointer of
			// addr.
			//
			// ref: http://llvm.org/docs/GetElementPtr.html#why-is-the-extra-0-index-required
			continue
		}
		switch ee := e.(type) {
		case *types.Pointer:
			// ref: http://llvm.org/docs/GetElementPtr.html#what-is-dereferenced-by-gep
			return nil, errutil.Newf(`unable to index into element of pointer type; for more information, see http://llvm.org/docs/GetElementPtr.html#what-is-dereferenced-by-gep`)
		case *types.Array:
			e = ee.Elem()
		case *types.Struct:
			idx, ok := index.(*Int)
			if !ok {
				return nil, errutil.Newf("invalid index type for structure element; expected *constant.Int, got %T", index)
			}
			e = ee.Fields()[idx.Value().Int64()]
		default:
			panic(fmt.Sprintf("constant.NewGetElementPtr: support for indexing element type %T not yet implemented", e))
		}
	}
	typ, err := types.NewPointer(e)
	if err != nil {
		return nil, errutil.Err(err)
	}
	return &GetElementPtr{typ: typ, elem: elem, addr: addr, indices: indices}, nil
}

// NewFAdd returns a new fadd instruction based on the given operands.
func NewFAdd(x, y value.Value) (*FAdd, error) {
	if !types.Equal(x.Type(), y.Type()) {
		return nil, errutil.Newf("type mismatch between x (%v) and y (%v)", x.Type(), y.Type())
	}
	return &FAdd{x: x, y: y}, nil
}

func TestEqual(t *testing.T) {
	golden := []struct {
		want bool
		a, b types.Type
	}{
		{want: true, a: voidTyp, b: voidTyp},
		{want: true, a: i1Typ, b: i1Typ},
		{want: true, a: i8Typ, b: i8Typ},
		{want: true, a: i32Typ, b: i32Typ},
		{want: true, a: f16Typ, b: f16Typ},
		{want: true, a: f32Typ, b: f32Typ},
		{want: true, a: f64Typ, b: f64Typ},
		{want: true, a: f128Typ, b: f128Typ},
		{want: true, a: f80_x86Typ, b: f80_x86Typ},
		{want: true, a: f128_ppcTyp, b: f128_ppcTyp},
		{want: true, a: mmxTyp, b: mmxTyp},
		{want: true, a: labelTyp, b: labelTyp},
		{want: true, a: metadataTyp, b: metadataTyp},
		{want: true, a: voidFuncTyp, b: voidFuncTyp},
		{want: true, a: i32FuncTyp, b: i32FuncTyp},
		{want: true, a: voidFunci32Typ, b: voidFunci32Typ},
		{want: true, a: voidFuncf32Typ, b: voidFuncf32Typ},
		{want: true, a: voidFunci32EllipsisTyp, b: voidFunci32EllipsisTyp},
		{want: true, a: funcTyp, b: funcTyp},
		{want: true, a: i8PtrTyp, b: i8PtrTyp},
		{want: true, a: f16PtrTyp, b: f16PtrTyp},
		{want: true, a: mmxPtrTyp, b: mmxPtrTyp},
		{want: true, a: funcPtrTyp, b: funcPtrTyp},
		{want: true, a: i8x1VecTyp, b: i8x1VecTyp},
		{want: true, a: i32x2VecTyp, b: i32x2VecTyp},
		{want: true, a: f16x3VecTyp, b: f16x3VecTyp},
		{want: true, a: f32x4VecTyp, b: f32x4VecTyp},
		{want: true, a: f64x5VecTyp, b: f64x5VecTyp},
		{want: true, a: f128x6VecTyp, b: f128x6VecTyp},
		{want: true, a: f80_x86x7VecTyp, b: f80_x86x7VecTyp},
		{want: true, a: f128_ppcx8VecTyp, b: f128_ppcx8VecTyp},
		{want: true, a: i8Ptrx9VecTyp, b: i8Ptrx9VecTyp},
		{want: true, a: f16Ptrx10VecTyp, b: f16Ptrx10VecTyp},
		{want: true, a: i8x1ArrTyp, b: i8x1ArrTyp},
		{want: true, a: i32x2ArrTyp, b: i32x2ArrTyp},
		{want: true, a: f16x3ArrTyp, b: f16x3ArrTyp},
		{want: true, a: f32x4ArrTyp, b: f32x4ArrTyp},
		{want: true, a: f64x5ArrTyp, b: f64x5ArrTyp},
		{want: true, a: f128x6ArrTyp, b: f128x6ArrTyp},
		{want: true, a: f80_x86x7ArrTyp, b: f80_x86x7ArrTyp},
		{want: true, a: f128_ppcx8ArrTyp, b: f128_ppcx8ArrTyp},
		{want: true, a: i8Ptrx9ArrTyp, b: i8Ptrx9ArrTyp},
		{want: true, a: f16Ptrx10ArrTyp, b: f16Ptrx10ArrTyp},
		{want: true, a: i32i8structTyp, b: i32i8structTyp},
		{want: true, a: i32i32structTyp, b: i32i32structTyp},
		{want: true, a: i32i8i8structTyp, b: i32i8i8structTyp},
		{want: true, a: structTyp, b: structTyp},
		{want: false, a: voidTyp, b: structTyp},
		{want: false, a: i1Typ, b: voidTyp},
		{want: false, a: i8Typ, b: i1Typ},
		{want: false, a: i32Typ, b: i8Typ},
		{want: false, a: f16Typ, b: i32Typ},
		{want: false, a: f32Typ, b: f16Typ},
		{want: false, a: f64Typ, b: f32Typ},
		{want: false, a: f128Typ, b: f64Typ},
		{want: false, a: f80_x86Typ, b: f128Typ},
		{want: false, a: f128_ppcTyp, b: f80_x86Typ},
		{want: false, a: mmxTyp, b: f128_ppcTyp},
		{want: false, a: labelTyp, b: mmxTyp},
		{want: false, a: metadataTyp, b: labelTyp},
		{want: false, a: voidFuncTyp, b: i32FuncTyp},
		{want: false, a: voidFuncTyp, b: voidFunci32Typ},
		{want: false, a: voidFunci32Typ, b: voidFuncf32Typ},
		{want: false, a: voidFunci32Typ, b: voidFunci32EllipsisTyp},
		{want: false, a: funcTyp, b: metadataTyp},
		{want: false, a: i8PtrTyp, b: funcTyp},
		{want: false, a: f16PtrTyp, b: i8PtrTyp},
		{want: false, a: mmxPtrTyp, b: f16PtrTyp},
		{want: false, a: funcPtrTyp, b: mmxPtrTyp},
		{want: false, a: i8x1VecTyp, b: funcPtrTyp},
		{want: false, a: i32x2VecTyp, b: i8x1VecTyp},
		{want: false, a: f16x3VecTyp, b: i32x2VecTyp},
		{want: false, a: f32x4VecTyp, b: f16x3VecTyp},
		{want: false, a: f64x5VecTyp, b: f32x4VecTyp},
		{want: false, a: f128x6VecTyp, b: f64x5VecTyp},
		{want: false, a: f80_x86x7VecTyp, b: f128x6VecTyp},
		{want: false, a: f128_ppcx8VecTyp, b: f80_x86x7VecTyp},
		{want: false, a: i8Ptrx9VecTyp, b: f128_ppcx8VecTyp},
		{want: false, a: f16Ptrx10VecTyp, b: i8Ptrx9VecTyp},
		{want: false, a: i8x1ArrTyp, b: f16Ptrx10VecTyp},
		{want: false, a: i32x2ArrTyp, b: i8x1ArrTyp},
		{want: false, a: f16x3ArrTyp, b: i32x2ArrTyp},
		{want: false, a: f32x4ArrTyp, b: f16x3ArrTyp},
		{want: false, a: f64x5ArrTyp, b: f32x4ArrTyp},
		{want: false, a: f128x6ArrTyp, b: f64x5ArrTyp},
		{want: false, a: f80_x86x7ArrTyp, b: f128x6ArrTyp},
		{want: false, a: f128_ppcx8ArrTyp, b: f80_x86x7ArrTyp},
		{want: false, a: i8Ptrx9ArrTyp, b: f128_ppcx8ArrTyp},
		{want: false, a: f16Ptrx10ArrTyp, b: i8Ptrx9ArrTyp},
		{want: false, a: i32i8structTyp, b: i32i8i8structTyp},
		{want: false, a: i32i8structTyp, b: i32i32structTyp},
		{want: false, a: structTyp, b: f16Ptrx10ArrTyp},
	}

	for i, g := range golden {
//.........这里部分代码省略.........