mirror of
https://github.com/golang/go.git
synced 2025-05-05 15:43:04 +00:00
cmd/compile: redo flag constant ops for arm64
Fixes the *noov opcodes so they handle a constant argument properly. Most of the infrastructure for this CL is in CL 238077 (the arm32 one). Fixes #39505 Change-Id: Id424a4e18964b848f05aa42f4d78e5f2e2cdf43b Reviewed-on: https://go-review.googlesource.com/c/go/+/237999 Reviewed-by: Cherry Zhang <cherryyz@google.com>
This commit is contained in:
Keith Randall
parent
40ef1faabc
commit
a07e28194a
@ -943,12 +943,8 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
|
||||
p := s.Prog(obj.AGETCALLERPC)
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = v.Reg()
|
||||
case ssa.OpARM64FlagEQ,
|
||||
ssa.OpARM64FlagLT_ULT,
|
||||
ssa.OpARM64FlagLT_UGT,
|
||||
ssa.OpARM64FlagGT_ULT,
|
||||
ssa.OpARM64FlagGT_UGT:
|
||||
v.Fatalf("Flag* ops should never make it to codegen %v", v.LongString())
|
||||
case ssa.OpARM64FlagConstant:
|
||||
v.Fatalf("FlagConstant op should never make it to codegen %v", v.LongString())
|
||||
case ssa.OpARM64InvertFlags:
|
||||
v.Fatalf("InvertFlags should never make it to codegen %v", v.LongString())
|
||||
case ssa.OpClobber:
|
||||
|
||||
@ -615,10 +615,10 @@
|
||||
(TEQconst (MOVWconst [x]) [y]) => (FlagConstant [logicFlags32(x^y)])
|
||||
|
||||
// other known comparisons
|
||||
(CMPconst (MOVBUreg _) [c]) && 0xff < c => (FlagConstant [subFlags32(0,1)])
|
||||
(CMPconst (MOVHUreg _) [c]) && 0xffff < c => (FlagConstant [subFlags32(0,1)])
|
||||
(CMPconst (ANDconst _ [m]) [n]) && 0 <= m && m < n => (FlagConstant [subFlags32(0,1)])
|
||||
(CMPconst (SRLconst _ [c]) [n]) && 0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n) => (FlagConstant [subFlags32(0,1)])
|
||||
(CMPconst (MOVBUreg _) [c]) && 0xff < c => (FlagConstant [subFlags32(0, 1)])
|
||||
(CMPconst (MOVHUreg _) [c]) && 0xffff < c => (FlagConstant [subFlags32(0, 1)])
|
||||
(CMPconst (ANDconst _ [m]) [n]) && 0 <= m && m < n => (FlagConstant [subFlags32(0, 1)])
|
||||
(CMPconst (SRLconst _ [c]) [n]) && 0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n) => (FlagConstant [subFlags32(0, 1)])
|
||||
|
||||
// absorb flag constants into branches
|
||||
(EQ (FlagConstant [fc]) yes no) && fc.eq() => (First yes no)
|
||||
|
||||
@ -1381,103 +1381,64 @@
|
||||
(MOVDreg (MOVDconst [c])) -> (MOVDconst [c])
|
||||
|
||||
// constant comparisons
|
||||
(CMPconst (MOVDconst [x]) [y]) && x==y -> (FlagEQ)
|
||||
(CMPconst (MOVDconst [x]) [y]) && x<y && uint64(x)<uint64(y) -> (FlagLT_ULT)
|
||||
(CMPconst (MOVDconst [x]) [y]) && x<y && uint64(x)>uint64(y) -> (FlagLT_UGT)
|
||||
(CMPconst (MOVDconst [x]) [y]) && x>y && uint64(x)<uint64(y) -> (FlagGT_ULT)
|
||||
(CMPconst (MOVDconst [x]) [y]) && x>y && uint64(x)>uint64(y) -> (FlagGT_UGT)
|
||||
(CMPWconst (MOVDconst [x]) [y]) && int32(x)==int32(y) -> (FlagEQ)
|
||||
(CMPWconst (MOVDconst [x]) [y]) && int32(x)<int32(y) && uint32(x)<uint32(y) -> (FlagLT_ULT)
|
||||
(CMPWconst (MOVDconst [x]) [y]) && int32(x)<int32(y) && uint32(x)>uint32(y) -> (FlagLT_UGT)
|
||||
(CMPWconst (MOVDconst [x]) [y]) && int32(x)>int32(y) && uint32(x)<uint32(y) -> (FlagGT_ULT)
|
||||
(CMPWconst (MOVDconst [x]) [y]) && int32(x)>int32(y) && uint32(x)>uint32(y) -> (FlagGT_UGT)
|
||||
(TSTconst (MOVDconst [x]) [y]) && int64(x&y)==0 -> (FlagEQ)
|
||||
(TSTconst (MOVDconst [x]) [y]) && int64(x&y)<0 -> (FlagLT_UGT)
|
||||
(TSTconst (MOVDconst [x]) [y]) && int64(x&y)>0 -> (FlagGT_UGT)
|
||||
(TSTWconst (MOVDconst [x]) [y]) && int32(x&y)==0 -> (FlagEQ)
|
||||
(TSTWconst (MOVDconst [x]) [y]) && int32(x&y)<0 -> (FlagLT_UGT)
|
||||
(TSTWconst (MOVDconst [x]) [y]) && int32(x&y)>0 -> (FlagGT_UGT)
|
||||
(CMNconst (MOVDconst [x]) [y]) && int64(x)==int64(-y) -> (FlagEQ)
|
||||
(CMNconst (MOVDconst [x]) [y]) && int64(x)<int64(-y) && uint64(x)<uint64(-y) -> (FlagLT_ULT)
|
||||
(CMNconst (MOVDconst [x]) [y]) && int64(x)<int64(-y) && uint64(x)>uint64(-y) -> (FlagLT_UGT)
|
||||
(CMNconst (MOVDconst [x]) [y]) && int64(x)>int64(-y) && uint64(x)<uint64(-y) -> (FlagGT_ULT)
|
||||
(CMNconst (MOVDconst [x]) [y]) && int64(x)>int64(-y) && uint64(x)>uint64(-y) -> (FlagGT_UGT)
|
||||
(CMNWconst (MOVDconst [x]) [y]) && int32(x)==int32(-y) -> (FlagEQ)
|
||||
(CMNWconst (MOVDconst [x]) [y]) && int32(x)<int32(-y) && uint32(x)<uint32(-y) -> (FlagLT_ULT)
|
||||
(CMNWconst (MOVDconst [x]) [y]) && int32(x)<int32(-y) && uint32(x)>uint32(-y) -> (FlagLT_UGT)
|
||||
(CMNWconst (MOVDconst [x]) [y]) && int32(x)>int32(-y) && uint32(x)<uint32(-y) -> (FlagGT_ULT)
|
||||
(CMNWconst (MOVDconst [x]) [y]) && int32(x)>int32(-y) && uint32(x)>uint32(-y) -> (FlagGT_UGT)
|
||||
|
||||
(CMPconst (MOVDconst [x]) [y]) => (FlagConstant [subFlags64(x,y)])
|
||||
(CMPWconst (MOVDconst [x]) [y]) => (FlagConstant [subFlags32(int32(x),y)])
|
||||
(TSTconst (MOVDconst [x]) [y]) => (FlagConstant [logicFlags64(x&y)])
|
||||
(TSTWconst (MOVDconst [x]) [y]) => (FlagConstant [logicFlags32(int32(x)&y)])
|
||||
(CMNconst (MOVDconst [x]) [y]) => (FlagConstant [addFlags64(x,y)])
|
||||
(CMNWconst (MOVDconst [x]) [y]) => (FlagConstant [addFlags32(int32(x),y)])
|
||||
|
||||
// other known comparisons
|
||||
(CMPconst (MOVBUreg _) [c]) && 0xff < c -> (FlagLT_ULT)
|
||||
(CMPconst (MOVHUreg _) [c]) && 0xffff < c -> (FlagLT_ULT)
|
||||
(CMPconst (MOVWUreg _) [c]) && 0xffffffff < c -> (FlagLT_ULT)
|
||||
(CMPconst (ANDconst _ [m]) [n]) && 0 <= m && m < n -> (FlagLT_ULT)
|
||||
(CMPconst (SRLconst _ [c]) [n]) && 0 <= n && 0 < c && c <= 63 && (1<<uint64(64-c)) <= uint64(n) -> (FlagLT_ULT)
|
||||
(CMPWconst (MOVBUreg _) [c]) && 0xff < int32(c) -> (FlagLT_ULT)
|
||||
(CMPWconst (MOVHUreg _) [c]) && 0xffff < int32(c) -> (FlagLT_ULT)
|
||||
(CMPconst (MOVBUreg _) [c]) && 0xff < c => (FlagConstant [subFlags64(0,1)])
|
||||
(CMPconst (MOVHUreg _) [c]) && 0xffff < c => (FlagConstant [subFlags64(0,1)])
|
||||
(CMPconst (MOVWUreg _) [c]) && 0xffffffff < c => (FlagConstant [subFlags64(0,1)])
|
||||
(CMPconst (ANDconst _ [m]) [n]) && 0 <= m && m < n => (FlagConstant [subFlags64(0,1)])
|
||||
(CMPconst (SRLconst _ [c]) [n]) && 0 <= n && 0 < c && c <= 63 && (1<<uint64(64-c)) <= uint64(n) => (FlagConstant [subFlags64(0,1)])
|
||||
(CMPWconst (MOVBUreg _) [c]) && 0xff < c => (FlagConstant [subFlags64(0,1)])
|
||||
(CMPWconst (MOVHUreg _) [c]) && 0xffff < c => (FlagConstant [subFlags64(0,1)])
|
||||
|
||||
// absorb flag constants into branches
|
||||
(EQ (FlagEQ) yes no) -> (First yes no)
|
||||
(EQ (FlagLT_ULT) yes no) -> (First no yes)
|
||||
(EQ (FlagLT_UGT) yes no) -> (First no yes)
|
||||
(EQ (FlagGT_ULT) yes no) -> (First no yes)
|
||||
(EQ (FlagGT_UGT) yes no) -> (First no yes)
|
||||
(EQ (FlagConstant [fc]) yes no) && fc.eq() => (First yes no)
|
||||
(EQ (FlagConstant [fc]) yes no) && !fc.eq() => (First no yes)
|
||||
|
||||
(NE (FlagEQ) yes no) -> (First no yes)
|
||||
(NE (FlagLT_ULT) yes no) -> (First yes no)
|
||||
(NE (FlagLT_UGT) yes no) -> (First yes no)
|
||||
(NE (FlagGT_ULT) yes no) -> (First yes no)
|
||||
(NE (FlagGT_UGT) yes no) -> (First yes no)
|
||||
(NE (FlagConstant [fc]) yes no) && fc.ne() => (First yes no)
|
||||
(NE (FlagConstant [fc]) yes no) && !fc.ne() => (First no yes)
|
||||
|
||||
(LT (FlagEQ) yes no) -> (First no yes)
|
||||
(LT (FlagLT_ULT) yes no) -> (First yes no)
|
||||
(LT (FlagLT_UGT) yes no) -> (First yes no)
|
||||
(LT (FlagGT_ULT) yes no) -> (First no yes)
|
||||
(LT (FlagGT_UGT) yes no) -> (First no yes)
|
||||
(LT (FlagConstant [fc]) yes no) && fc.lt() => (First yes no)
|
||||
(LT (FlagConstant [fc]) yes no) && !fc.lt() => (First no yes)
|
||||
|
||||
(LE (FlagEQ) yes no) -> (First yes no)
|
||||
(LE (FlagLT_ULT) yes no) -> (First yes no)
|
||||
(LE (FlagLT_UGT) yes no) -> (First yes no)
|
||||
(LE (FlagGT_ULT) yes no) -> (First no yes)
|
||||
(LE (FlagGT_UGT) yes no) -> (First no yes)
|
||||
(LE (FlagConstant [fc]) yes no) && fc.le() => (First yes no)
|
||||
(LE (FlagConstant [fc]) yes no) && !fc.le() => (First no yes)
|
||||
|
||||
(GT (FlagEQ) yes no) -> (First no yes)
|
||||
(GT (FlagLT_ULT) yes no) -> (First no yes)
|
||||
(GT (FlagLT_UGT) yes no) -> (First no yes)
|
||||
(GT (FlagGT_ULT) yes no) -> (First yes no)
|
||||
(GT (FlagGT_UGT) yes no) -> (First yes no)
|
||||
(GT (FlagConstant [fc]) yes no) && fc.gt() => (First yes no)
|
||||
(GT (FlagConstant [fc]) yes no) && !fc.gt() => (First no yes)
|
||||
|
||||
(GE (FlagEQ) yes no) -> (First yes no)
|
||||
(GE (FlagLT_ULT) yes no) -> (First no yes)
|
||||
(GE (FlagLT_UGT) yes no) -> (First no yes)
|
||||
(GE (FlagGT_ULT) yes no) -> (First yes no)
|
||||
(GE (FlagGT_UGT) yes no) -> (First yes no)
|
||||
(GE (FlagConstant [fc]) yes no) && fc.ge() => (First yes no)
|
||||
(GE (FlagConstant [fc]) yes no) && !fc.ge() => (First no yes)
|
||||
|
||||
(ULT (FlagEQ) yes no) -> (First no yes)
|
||||
(ULT (FlagLT_ULT) yes no) -> (First yes no)
|
||||
(ULT (FlagLT_UGT) yes no) -> (First no yes)
|
||||
(ULT (FlagGT_ULT) yes no) -> (First yes no)
|
||||
(ULT (FlagGT_UGT) yes no) -> (First no yes)
|
||||
(ULT (FlagConstant [fc]) yes no) && fc.ult() => (First yes no)
|
||||
(ULT (FlagConstant [fc]) yes no) && !fc.ult() => (First no yes)
|
||||
|
||||
(ULE (FlagEQ) yes no) -> (First yes no)
|
||||
(ULE (FlagLT_ULT) yes no) -> (First yes no)
|
||||
(ULE (FlagLT_UGT) yes no) -> (First no yes)
|
||||
(ULE (FlagGT_ULT) yes no) -> (First yes no)
|
||||
(ULE (FlagGT_UGT) yes no) -> (First no yes)
|
||||
(ULE (FlagConstant [fc]) yes no) && fc.ule() => (First yes no)
|
||||
(ULE (FlagConstant [fc]) yes no) && !fc.ule() => (First no yes)
|
||||
|
||||
(UGT (FlagEQ) yes no) -> (First no yes)
|
||||
(UGT (FlagLT_ULT) yes no) -> (First no yes)
|
||||
(UGT (FlagLT_UGT) yes no) -> (First yes no)
|
||||
(UGT (FlagGT_ULT) yes no) -> (First no yes)
|
||||
(UGT (FlagGT_UGT) yes no) -> (First yes no)
|
||||
(UGT (FlagConstant [fc]) yes no) && fc.ugt() => (First yes no)
|
||||
(UGT (FlagConstant [fc]) yes no) && !fc.ugt() => (First no yes)
|
||||
|
||||
(UGE (FlagEQ) yes no) -> (First yes no)
|
||||
(UGE (FlagLT_ULT) yes no) -> (First no yes)
|
||||
(UGE (FlagLT_UGT) yes no) -> (First yes no)
|
||||
(UGE (FlagGT_ULT) yes no) -> (First no yes)
|
||||
(UGE (FlagGT_UGT) yes no) -> (First yes no)
|
||||
(UGE (FlagConstant [fc]) yes no) && fc.uge() => (First yes no)
|
||||
(UGE (FlagConstant [fc]) yes no) && !fc.uge() => (First no yes)
|
||||
|
||||
(LTnoov (FlagConstant [fc]) yes no) && fc.ltNoov() => (First yes no)
|
||||
(LTnoov (FlagConstant [fc]) yes no) && !fc.ltNoov() => (First no yes)
|
||||
|
||||
(LEnoov (FlagConstant [fc]) yes no) && fc.leNoov() => (First yes no)
|
||||
(LEnoov (FlagConstant [fc]) yes no) && !fc.leNoov() => (First no yes)
|
||||
|
||||
(GTnoov (FlagConstant [fc]) yes no) && fc.gtNoov() => (First yes no)
|
||||
(GTnoov (FlagConstant [fc]) yes no) && !fc.gtNoov() => (First no yes)
|
||||
|
||||
(GEnoov (FlagConstant [fc]) yes no) && fc.geNoov() => (First yes no)
|
||||
(GEnoov (FlagConstant [fc]) yes no) && !fc.geNoov() => (First no yes)
|
||||
|
||||
(Z (MOVDconst [0]) yes no) -> (First yes no)
|
||||
(Z (MOVDconst [c]) yes no) && c != 0 -> (First no yes)
|
||||
@ -1513,65 +1474,16 @@
|
||||
(CSEL0 {cc} x (InvertFlags cmp)) -> (CSEL0 {arm64Invert(cc.(Op))} x cmp)
|
||||
|
||||
// absorb flag constants into boolean values
|
||||
(Equal (FlagEQ)) -> (MOVDconst [1])
|
||||
(Equal (FlagLT_ULT)) -> (MOVDconst [0])
|
||||
(Equal (FlagLT_UGT)) -> (MOVDconst [0])
|
||||
(Equal (FlagGT_ULT)) -> (MOVDconst [0])
|
||||
(Equal (FlagGT_UGT)) -> (MOVDconst [0])
|
||||
|
||||
(NotEqual (FlagEQ)) -> (MOVDconst [0])
|
||||
(NotEqual (FlagLT_ULT)) -> (MOVDconst [1])
|
||||
(NotEqual (FlagLT_UGT)) -> (MOVDconst [1])
|
||||
(NotEqual (FlagGT_ULT)) -> (MOVDconst [1])
|
||||
(NotEqual (FlagGT_UGT)) -> (MOVDconst [1])
|
||||
|
||||
(LessThan (FlagEQ)) -> (MOVDconst [0])
|
||||
(LessThan (FlagLT_ULT)) -> (MOVDconst [1])
|
||||
(LessThan (FlagLT_UGT)) -> (MOVDconst [1])
|
||||
(LessThan (FlagGT_ULT)) -> (MOVDconst [0])
|
||||
(LessThan (FlagGT_UGT)) -> (MOVDconst [0])
|
||||
|
||||
(LessThanU (FlagEQ)) -> (MOVDconst [0])
|
||||
(LessThanU (FlagLT_ULT)) -> (MOVDconst [1])
|
||||
(LessThanU (FlagLT_UGT)) -> (MOVDconst [0])
|
||||
(LessThanU (FlagGT_ULT)) -> (MOVDconst [1])
|
||||
(LessThanU (FlagGT_UGT)) -> (MOVDconst [0])
|
||||
|
||||
(LessEqual (FlagEQ)) -> (MOVDconst [1])
|
||||
(LessEqual (FlagLT_ULT)) -> (MOVDconst [1])
|
||||
(LessEqual (FlagLT_UGT)) -> (MOVDconst [1])
|
||||
(LessEqual (FlagGT_ULT)) -> (MOVDconst [0])
|
||||
(LessEqual (FlagGT_UGT)) -> (MOVDconst [0])
|
||||
|
||||
(LessEqualU (FlagEQ)) -> (MOVDconst [1])
|
||||
(LessEqualU (FlagLT_ULT)) -> (MOVDconst [1])
|
||||
(LessEqualU (FlagLT_UGT)) -> (MOVDconst [0])
|
||||
(LessEqualU (FlagGT_ULT)) -> (MOVDconst [1])
|
||||
(LessEqualU (FlagGT_UGT)) -> (MOVDconst [0])
|
||||
|
||||
(GreaterThan (FlagEQ)) -> (MOVDconst [0])
|
||||
(GreaterThan (FlagLT_ULT)) -> (MOVDconst [0])
|
||||
(GreaterThan (FlagLT_UGT)) -> (MOVDconst [0])
|
||||
(GreaterThan (FlagGT_ULT)) -> (MOVDconst [1])
|
||||
(GreaterThan (FlagGT_UGT)) -> (MOVDconst [1])
|
||||
|
||||
(GreaterThanU (FlagEQ)) -> (MOVDconst [0])
|
||||
(GreaterThanU (FlagLT_ULT)) -> (MOVDconst [0])
|
||||
(GreaterThanU (FlagLT_UGT)) -> (MOVDconst [1])
|
||||
(GreaterThanU (FlagGT_ULT)) -> (MOVDconst [0])
|
||||
(GreaterThanU (FlagGT_UGT)) -> (MOVDconst [1])
|
||||
|
||||
(GreaterEqual (FlagEQ)) -> (MOVDconst [1])
|
||||
(GreaterEqual (FlagLT_ULT)) -> (MOVDconst [0])
|
||||
(GreaterEqual (FlagLT_UGT)) -> (MOVDconst [0])
|
||||
(GreaterEqual (FlagGT_ULT)) -> (MOVDconst [1])
|
||||
(GreaterEqual (FlagGT_UGT)) -> (MOVDconst [1])
|
||||
|
||||
(GreaterEqualU (FlagEQ)) -> (MOVDconst [1])
|
||||
(GreaterEqualU (FlagLT_ULT)) -> (MOVDconst [0])
|
||||
(GreaterEqualU (FlagLT_UGT)) -> (MOVDconst [1])
|
||||
(GreaterEqualU (FlagGT_ULT)) -> (MOVDconst [0])
|
||||
(GreaterEqualU (FlagGT_UGT)) -> (MOVDconst [1])
|
||||
(Equal (FlagConstant [fc])) => (MOVDconst [b2i(fc.eq())])
|
||||
(NotEqual (FlagConstant [fc])) => (MOVDconst [b2i(fc.ne())])
|
||||
(LessThan (FlagConstant [fc])) => (MOVDconst [b2i(fc.lt())])
|
||||
(LessThanU (FlagConstant [fc])) => (MOVDconst [b2i(fc.ult())])
|
||||
(LessEqual (FlagConstant [fc])) => (MOVDconst [b2i(fc.le())])
|
||||
(LessEqualU (FlagConstant [fc])) => (MOVDconst [b2i(fc.ule())])
|
||||
(GreaterThan (FlagConstant [fc])) => (MOVDconst [b2i(fc.gt())])
|
||||
(GreaterThanU (FlagConstant [fc])) => (MOVDconst [b2i(fc.ugt())])
|
||||
(GreaterEqual (FlagConstant [fc])) => (MOVDconst [b2i(fc.ge())])
|
||||
(GreaterEqualU (FlagConstant [fc])) => (MOVDconst [b2i(fc.uge())])
|
||||
|
||||
// absorb InvertFlags into boolean values
|
||||
(Equal (InvertFlags x)) -> (Equal x)
|
||||
|
||||
@ -587,18 +587,12 @@ func init() {
|
||||
// See runtime/stubs.go for a more detailed discussion.
|
||||
{name: "LoweredGetCallerPC", reg: gp01, rematerializeable: true},
|
||||
|
||||
// Constant flag values. For any comparison, there are 5 possible
|
||||
// outcomes: the three from the signed total order (<,==,>) and the
|
||||
// three from the unsigned total order. The == cases overlap.
|
||||
// Note: there's a sixth "unordered" outcome for floating-point
|
||||
// Constant flag value.
|
||||
// Note: there's an "unordered" outcome for floating-point
|
||||
// comparisons, but we don't use such a beast yet.
|
||||
// These ops are for temporary use by rewrite rules. They
|
||||
// This op is for temporary use by rewrite rules. It
|
||||
// cannot appear in the generated assembly.
|
||||
{name: "FlagEQ"}, // equal
|
||||
{name: "FlagLT_ULT"}, // signed < and unsigned <
|
||||
{name: "FlagLT_UGT"}, // signed < and unsigned >
|
||||
{name: "FlagGT_UGT"}, // signed > and unsigned <
|
||||
{name: "FlagGT_ULT"}, // signed > and unsigned >
|
||||
{name: "FlagConstant", aux: "FlagConstant"},
|
||||
|
||||
// (InvertFlags (CMP a b)) == (CMP b a)
|
||||
// InvertFlags is a pseudo-op which can't appear in assembly output.
|
||||
|
||||
@ -1554,11 +1554,7 @@ const (
|
||||
OpARM64LoweredGetClosurePtr
|
||||
OpARM64LoweredGetCallerSP
|
||||
OpARM64LoweredGetCallerPC
|
||||
OpARM64FlagEQ
|
||||
OpARM64FlagLT_ULT
|
||||
OpARM64FlagLT_UGT
|
||||
OpARM64FlagGT_UGT
|
||||
OpARM64FlagGT_ULT
|
||||
OpARM64FlagConstant
|
||||
OpARM64InvertFlags
|
||||
OpARM64LDAR
|
||||
OpARM64LDARB
|
||||
@ -20498,29 +20494,10 @@ var opcodeTable = [...]opInfo{
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "FlagEQ",
|
||||
argLen: 0,
|
||||
reg: regInfo{},
|
||||
},
|
||||
{
|
||||
name: "FlagLT_ULT",
|
||||
argLen: 0,
|
||||
reg: regInfo{},
|
||||
},
|
||||
{
|
||||
name: "FlagLT_UGT",
|
||||
argLen: 0,
|
||||
reg: regInfo{},
|
||||
},
|
||||
{
|
||||
name: "FlagGT_UGT",
|
||||
argLen: 0,
|
||||
reg: regInfo{},
|
||||
},
|
||||
{
|
||||
name: "FlagGT_ULT",
|
||||
argLen: 0,
|
||||
reg: regInfo{},
|
||||
name: "FlagConstant",
|
||||
auxType: auxFlagConstant,
|
||||
argLen: 0,
|
||||
reg: regInfo{},
|
||||
},
|
||||
{
|
||||
name: "InvertFlags",
|
||||
|
||||
@ -1011,52 +1011,42 @@ func arm64Invert(op Op) Op {
|
||||
func ccARM64Eval(cc interface{}, flags *Value) int {
|
||||
op := cc.(Op)
|
||||
fop := flags.Op
|
||||
switch fop {
|
||||
case OpARM64InvertFlags:
|
||||
if fop == OpARM64InvertFlags {
|
||||
return -ccARM64Eval(op, flags.Args[0])
|
||||
case OpARM64FlagEQ:
|
||||
switch op {
|
||||
case OpARM64Equal, OpARM64GreaterEqual, OpARM64LessEqual,
|
||||
OpARM64GreaterEqualU, OpARM64LessEqualU:
|
||||
return 1
|
||||
default:
|
||||
return -1
|
||||
}
|
||||
case OpARM64FlagLT_ULT:
|
||||
switch op {
|
||||
case OpARM64LessThan, OpARM64LessThanU,
|
||||
OpARM64LessEqual, OpARM64LessEqualU:
|
||||
return 1
|
||||
default:
|
||||
return -1
|
||||
}
|
||||
case OpARM64FlagLT_UGT:
|
||||
switch op {
|
||||
case OpARM64LessThan, OpARM64GreaterThanU,
|
||||
OpARM64LessEqual, OpARM64GreaterEqualU:
|
||||
return 1
|
||||
default:
|
||||
return -1
|
||||
}
|
||||
case OpARM64FlagGT_ULT:
|
||||
switch op {
|
||||
case OpARM64GreaterThan, OpARM64LessThanU,
|
||||
OpARM64GreaterEqual, OpARM64LessEqualU:
|
||||
return 1
|
||||
default:
|
||||
return -1
|
||||
}
|
||||
case OpARM64FlagGT_UGT:
|
||||
switch op {
|
||||
case OpARM64GreaterThan, OpARM64GreaterThanU,
|
||||
OpARM64GreaterEqual, OpARM64GreaterEqualU:
|
||||
return 1
|
||||
default:
|
||||
return -1
|
||||
}
|
||||
default:
|
||||
}
|
||||
if fop != OpARM64FlagConstant {
|
||||
return 0
|
||||
}
|
||||
fc := flagConstant(flags.AuxInt)
|
||||
b2i := func(b bool) int {
|
||||
if b {
|
||||
return 1
|
||||
}
|
||||
return -1
|
||||
}
|
||||
switch op {
|
||||
case OpARM64Equal:
|
||||
return b2i(fc.eq())
|
||||
case OpARM64NotEqual:
|
||||
return b2i(fc.ne())
|
||||
case OpARM64LessThan:
|
||||
return b2i(fc.lt())
|
||||
case OpARM64LessThanU:
|
||||
return b2i(fc.ult())
|
||||
case OpARM64GreaterThan:
|
||||
return b2i(fc.gt())
|
||||
case OpARM64GreaterThanU:
|
||||
return b2i(fc.ugt())
|
||||
case OpARM64LessEqual:
|
||||
return b2i(fc.le())
|
||||
case OpARM64LessEqualU:
|
||||
return b2i(fc.ule())
|
||||
case OpARM64GreaterEqual:
|
||||
return b2i(fc.ge())
|
||||
case OpARM64GreaterEqualU:
|
||||
return b2i(fc.uge())
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// logRule logs the use of the rule s. This will only be enabled if
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user