support signatures and param load/stores

operand/checks.go

@@ -109,6 +109,11 @@ func IsR64(op Op) bool {
 	return IsGP(op, 8)
 }
 
+// IsPseudo returns true if op is a pseudo register.
+func IsPseudo(op Op) bool {
+	return IsRegisterKindSize(op, reg.Internal, 0)
+}
+
 // IsGP returns true if op is a general-purpose register of size n bytes.
 func IsGP(op Op, n uint) bool {
 	return IsRegisterKindSize(op, reg.GP, n)
@@ -171,7 +176,12 @@ func IsM64(op Op) bool {
 func IsMSize(op Op, n uint) bool {
 	// TODO(mbm): should memory operands have a size attribute as well?
 	m, ok := op.(Mem)
-	return ok && IsGP(m.Base, n) && (m.Index == nil || IsGP(m.Index, n))
+	return ok && IsMRegSize(m.Base, n) && (m.Index == nil || IsMRegSize(m.Index, n))
+}
+
+// IsMRegSize returns true if op is a register that can be used in a memory operand of size n bytes.
+func IsMRegSize(op Op, n uint) bool {
+	return IsPseudo(op) || IsGP(op, n)
 }
 
 // IsM128 returns true if op is a 128-bit memory operand.

operand/checks_test.go

@@ -85,6 +85,14 @@ func TestChecks(t *testing.T) {
 		{IsYmm, reg.X3, false},
 		{IsYmm, reg.Z3, false},
 
+		// Pseudo registers.
+		{IsPseudo, reg.FramePointer, true},
+		{IsPseudo, reg.ProgramCounter, true},
+		{IsPseudo, reg.StaticBase, true},
+		{IsPseudo, reg.StackPointer, true},
+		{IsPseudo, reg.ECX, false},
+		{IsPseudo, reg.X9, false},
+
 		// Memory operands
 		{IsM, Mem{Base: reg.CX}, true},
 		{IsM, Mem{Base: reg.ECX}, true},
@@ -113,6 +121,13 @@ func TestChecks(t *testing.T) {
 		{IsM256, Mem{Base: reg.RBX, Index: reg.R12, Scale: 2}, true},
 		{IsM256, Mem{Base: reg.R13L}, false},
 
+		// Argument references (special cases of memory operands)
+		{IsM, NewParamAddr("foo", 4), true},
+		{IsM8, NewParamAddr("foo", 4), true},
+		{IsM16, NewParamAddr("foo", 4), true},
+		{IsM32, NewParamAddr("foo", 4), true},
+		{IsM64, NewParamAddr("foo", 4), true},
+
 		// Vector memory operands
 		{IsVm32x, Mem{Base: reg.R14, Index: reg.X11}, true},
 		{IsVm32x, Mem{Base: reg.R14L, Index: reg.X11}, false},