Golang Value.Type方法代码示例

func (v Target) moveFloatToSSEReg(a *allocator, val ssa.Value, reg string) {
	float := val.Type().(*types.Float)
	com := moveInstrForFloatType(float.Type())

	if lit, ok := val.(*ssa.FloatLiteral); ok {
		v.wop("pushq $0x%x", lit.LiteralValue())
		v.wop("%s (#rsp), %s", com, reg)
		v.wop("addq $8, #rsp")
	} else {
		v.wop("%s %s, #%s", com, a.valStr(val), reg)
	}
}

func (v Target) moveRegToVal(a *allocator, reg string, val ssa.Value) {
	storesz := TypeStoreSizeInBits(val.Type())
	reg = regToSize(reg, storesz)

	if storesz > 64 {
		panic("unim")
	}
	if !isPow2(storesz) {
		panic("unim")
	}

	v.wop("mov%s #%s, %s", sizeSuffixBits(storesz), reg, a.valStr(val))
}

func (v Target) winSaveFunctionParameter(a *allocator, par ssa.Value, i int) {
	reg := i < 4
	storesz := TypeStoreSizeInBits(par.Type())

	if winIsMemory(par.Type()) {
		if reg {
			v.moveMemToMem(winIntRegs[i], "rbp", 0, -a.valOffset(par), storesz/8)
		} else {
			v.wop("movq $%d(#rbp), #r11", 16+i*8)
			v.moveMemToMem("r11", "rbp", 0, -a.valOffset(par), storesz/8)
		}
	} else if winIsInteger(par.Type()) {
		if reg {
			v.wop("mov%s #%s, %d(#rbp)", sizeSuffixBits(storesz), regToSize(winIntRegs[i], storesz), -a.valOffset(par))
		} else {
			v.wop("movq $%d(#rbp), #r11", 16+i*8)
			v.wop("mov%s #%s, %d(#rbp)", sizeSuffixBits(storesz), regToSize("r11", storesz), -a.valOffset(par))
		}
	} else if winIsFloat(par.Type()) {
		if reg {
			v.moveSSERegToFloat(a, winSseRegs[i], par)
		} else {
			//v.moveValToMem(a, arg, "rsp", 0)
			panic("unim")
		}
	} else {
		panic("unim")
	}
}

func (v Target) sysVCopyReturnValue(a *allocator, val ssa.Value, saving bool) {
	if val == nil {
		return
	}
	if _, ok := val.Type().(types.Void); ok {
		return
	}

	classList := sysVClassifyType(val.Type())

	switch val.Type().(type) {
	case *types.Struct, *types.Array:
		panic("unim")
	}

	if len(classList) != 1 {
		panic("internal error: non-aggregate type has ABI classList of length > 1")
	}

	class := classList[0]

	switch class {
	case sysVClassINTEGER:
		storesz := TypeStoreSizeInBits(val.Type())
		if saving {
			v.wop("mov%s #%s, %s", sizeSuffixBits(storesz), regToSize("rax", storesz), a.valStr(val))
		} else {
			v.moveIntToReg(a, val, "rax")
		}

	default:
		panic("unim")
	}
}

// non-float types of sz <= 64, where sz is pow 2 are returned in rax
// float types are returned in xmm0
// everything else is returned via memory, location is returned in rax
// assumes memory return location is saved in %r15
func (v Target) winCopyReturnValue(a *allocator, val ssa.Value, saving bool) {
	if _, ok := val.Type().(types.Void); ok {
		return
	}

	storesz := TypeStoreSizeInBits(val.Type())

	if _, ok := val.Type().(*types.Float); ok {
		if saving {
			v.moveSSERegToFloat(a, "xmm0", val)
		} else {
			v.moveFloatToSSEReg(a, val, "xmm0")
		}
		return
	}

	if storesz <= 64 && isPow2(storesz) {
		if saving {
			v.wop("mov%s #%s, %s", sizeSuffixBits(storesz), regToSize("rax", storesz), a.valStr(val))
		} else {
			v.moveIntToReg(a, val, "rax")
		}
		return
	}

	if saving {
		v.moveMemToMem("rax", "rbp", 0, -a.valOffset(val), storesz/8)
	} else {
		v.wop("movq #r15, #rax")
		v.moveValToMem(a, val, "rax", 0)
	}
}

func (v Target) moveValToMem(a *allocator, src ssa.Value, memReg string, memOffset int) {
	/*if !src.Type().Equals(dest.Type()) {
		panic("internal error")
	}*/

	checkTypeSupported(src.Type())

	storesz := TypeStoreSizeInBits(src.Type())

	switch src.Type().(type) {
	case *types.Int, *types.Pointer:
		if lit, ok := src.(*ssa.IntLiteral); ok {
			v.wop("mov%s $%d, %d(#%s)", sizeSuffixBits(storesz), lit.LiteralValue(), memOffset, memReg)
		} else {
			v.wop("mov%s %s, #%s", sizeSuffixBits(storesz), a.valStr(src), regToSize("rax", storesz))
			v.wop("mov%s #%s, %d(#%s)", sizeSuffixBits(storesz), regToSize("rax", storesz), memOffset, memReg)
		}

	default:
		panic("unim")
	}
}

// TODO rename
func (v Target) moveIntToReg(a *allocator, val ssa.Value, reg string) {
	storesz := TypeStoreSizeInBits(val.Type())
	reg = regToSize(reg, storesz)
	reg64 := regToSize(reg, 64)

	if storesz > 64 {
		panic("unim")
	}
	if !isPow2(storesz) {
		panic("unim")
	}

	if storesz != 64 {
		v.wop("xorq #%s, #%s", reg64, reg64)
	}

	if lit, ok := val.(*ssa.IntLiteral); ok {
		v.wop("mov%s $%d, #%s", sizeSuffixBits(storesz), lit.LiteralValue(), reg)
	} else {
		v.wop("mov%s %s, #%s", sizeSuffixBits(storesz), a.valStr(val), reg)
	}
}

func (v Target) winLoadCallArgument(a *allocator, arg ssa.Value, i int) {
	reg := i < 4

	if !reg {
		v.wop("subq $8, #rsp")
	}

	if winIsMemory(arg.Type()) {
		storesz := TypeStoreSizeInBits(arg.Type())
		v.moveValToMem(a, arg, "r11", 0)

		if reg {
			v.wop("movq #r11, #%s", winIntRegs[i])
		} else {
			v.wop("movq #r11, #rsp")
		}

		addbits := storesz
		for addbits%(16*8) != 0 { // TODO do this better
			addbits++
		}
		v.wop("addq $%d, #r11", addbits/8)

	} else if winIsInteger(arg.Type()) {
		if reg {
			v.moveIntToReg(a, arg, winIntRegs[i])
		} else {
			v.moveValToMem(a, arg, "rsp", 0)
		}
	} else if winIsFloat(arg.Type()) {
		if reg {
			v.moveIntToReg(a, arg, winIntRegs[i])
			v.moveFloatToSSEReg(a, arg, winSseRegs[i])
		} else {
			v.moveValToMem(a, arg, "rsp", 0)
		}
	} else {
		panic(arg)
	}
}

func (v *allocator) allocateValue(val ssa.Value) {
	if _, ok := val.Type().(types.Void); ok {
		return
	}

	if _, ok := v.valOffsets[val]; ok {
		panic("duplicate val")
	}

	sz := TypeStoreSizeInBits(val.Type()) / 8
	align := TypeAlignmentInBits(val.Type()) / 8

	v.stackSize += sz
	for v.stackSize%align != 0 {
		v.stackSize++
	}
	v.valOffsets[val] = v.stackSize
}

func (v Target) moveSSERegToFloat(a *allocator, reg string, val ssa.Value) {
	float := val.Type().(*types.Float)
	com := moveInstrForFloatType(float.Type())

	v.wop("%s #%s, %s", com, reg, a.valStr(val))
}