cmd/internal/obj/arm: remove CASE and BCASE

Update #10994

CASE and BCASE were used by 5c in switch statements, cmd/compile
does not use them.

Change-Id: I7a578c461b52b94690e35460926849b28971b770
Reviewed-on: https://go-review.googlesource.com/14009
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Minux Ma <minux@golang.org>
Run-TryBot: Minux Ma <minux@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

diff --git a/src/cmd/asm/internal/asm/testdata/arm.out b/src/cmd/asm/internal/asm/testdata/arm.out
index 7501db3e5aac462e848c2eeb6412bcebd9c7db4e..ffd520d729caaa078ff1ee5e5468f3859eb5aeaa 100644 (file)
--- a/src/cmd/asm/internal/asm/testdata/arm.out
+++ b/src/cmd/asm/internal/asm/testdata/arm.out
@@ -37,23 +37,22 @@
 154 00037 (testdata/arm.s:154) STREX.S (R2), R1, R3
 160 00038 (testdata/arm.s:160) STREX.S (R2), R1, R1
 166 00039 (testdata/arm.s:166) STREX.S (R2), R3, R3
-174 00040 (testdata/arm.s:174) CASE.S  R1
-183 00041 (testdata/arm.s:183) WORD    $1234
-192 00042 (testdata/arm.s:192) ABSF.S  F1, F2
-198 00043 (testdata/arm.s:198) ADDD.S  F1, F2
-199 00044 (testdata/arm.s:199) ADDD.S  $(0.5), F2
-205 00045 (testdata/arm.s:205) ADDD.S  F1, F2, F3
-206 00046 (testdata/arm.s:206) ADDD.S  $(0.5), F2, F3
-212 00047 (testdata/arm.s:212) CMPD.S  F1, F2
-236 00048 (testdata/arm.s:236) MRC     $8301712627
-237 00049 (testdata/arm.s:237) MRC     $8300664051
-246 00050 (testdata/arm.s:246) MULL    R1, R2, (R3, R4)
-258 00051 (testdata/arm.s:258) MULAWT  R1, R2, R3, R4
-266 00052 (testdata/arm.s:266) PLD     (R1)
-267 00053 (testdata/arm.s:267) PLD     4(R1)
-276 00054 (testdata/arm.s:276) RET
-280 00055 (testdata/arm.s:280) JMP     foo(SB)
-281 00056 (testdata/arm.s:281) CALL    foo(SB)
-282 00057 (testdata/arm.s:282) JMP     foo(SB)
-283 00058 (testdata/arm.s:283) CALL    foo(SB)
-292 00059 (testdata/arm.s:292) END
+175 00040 (testdata/arm.s:175) WORD    $1234
+184 00041 (testdata/arm.s:184) ABSF.S  F1, F2
+190 00042 (testdata/arm.s:190) ADDD.S  F1, F2
+191 00043 (testdata/arm.s:191) ADDD.S  $(0.5), F2
+197 00044 (testdata/arm.s:197) ADDD.S  F1, F2, F3
+198 00045 (testdata/arm.s:198) ADDD.S  $(0.5), F2, F3
+204 00046 (testdata/arm.s:204) CMPD.S  F1, F2
+228 00047 (testdata/arm.s:228) MRC     $8301712627
+229 00048 (testdata/arm.s:229) MRC     $8300664051
+238 00049 (testdata/arm.s:238) MULL    R1, R2, (R3, R4)
+250 00050 (testdata/arm.s:250) MULAWT  R1, R2, R3, R4
+258 00051 (testdata/arm.s:258) PLD     (R1)
+259 00052 (testdata/arm.s:259) PLD     4(R1)
+268 00053 (testdata/arm.s:268) RET
+272 00054 (testdata/arm.s:272) JMP     foo(SB)
+273 00055 (testdata/arm.s:273) CALL    foo(SB)
+274 00056 (testdata/arm.s:274) JMP     foo(SB)
+275 00057 (testdata/arm.s:275) CALL    foo(SB)
+284 00058 (testdata/arm.s:284) END

diff --git a/src/cmd/asm/internal/asm/testdata/arm.s b/src/cmd/asm/internal/asm/testdata/arm.s
index b8bdfb201a168a566a9537c9ea004f98b3493312..93557923b0752e104485afe574d0907914632134 100644 (file)
--- a/src/cmd/asm/internal/asm/testdata/arm.s
+++ b/src/cmd/asm/internal/asm/testdata/arm.s
@@ -165,14 +165,6 @@ TEXT       foo(SB), 0, $0
 //     }
        STREX.S (R2), R3
 
-// CASE
-//
-//     LTYPED cond reg
-//     {
-//             outcode($1, $2, &$3, 0, &nullgen);
-//     }
-       CASE.S  R1
-
 //
 // word
 //

diff --git a/src/cmd/compile/internal/arm/peep.go b/src/cmd/compile/internal/arm/peep.go
index 66eba417c02f231b1ee42b80a7fcd247b9081e76..4fba43461932f73e3f94eabd814bbca70477bfca 100644 (file)
--- a/src/cmd/compile/internal/arm/peep.go
+++ b/src/cmd/compile/internal/arm/peep.go
@@ -1198,7 +1198,6 @@ func copyu(p *obj.Prog, v *obj.Addr, s *obj.Addr) int {
                arm.ACMPD,
                arm.ACMP,
                arm.ACMN,
-               arm.ACASE,
                arm.ATST:
                /* read,, */
                if s != nil {
@@ -1560,9 +1559,7 @@ func predicable(p *obj.Prog) bool {
                obj.ADATA,
                obj.AGLOBL,
                obj.ATEXT,
-               arm.AWORD,
-               arm.ABCASE,
-               arm.ACASE:
+               arm.AWORD:
                return false
        }
 

diff --git a/src/cmd/internal/obj/arm/a.out.go b/src/cmd/internal/obj/arm/a.out.go
index 1cb561d4b2939efaf91671c82cf4221f349d1294..6c9cfd52d160975bcf7497519084d5178c443ccf 100644 (file)
--- a/src/cmd/internal/obj/arm/a.out.go
+++ b/src/cmd/internal/obj/arm/a.out.go
@@ -251,8 +251,6 @@ const (
        AMULA
 
        AWORD
-       ABCASE
-       ACASE
 
        AMULL
        AMULAL

diff --git a/src/cmd/internal/obj/arm/anames.go b/src/cmd/internal/obj/arm/anames.go
index 1a924f0381b2ed30ac105fc2f229f73107ea7c29..0ef68a6be248638c01b3984f67b2e2e5d37d0104 100644 (file)
--- a/src/cmd/internal/obj/arm/anames.go
+++ b/src/cmd/internal/obj/arm/anames.go
@@ -82,8 +82,6 @@ var Anames = []string{
        "SWI",
        "MULA",
        "WORD",
-       "BCASE",
-       "CASE",
        "MULL",
        "MULAL",
        "MULLU",

diff --git a/src/cmd/internal/obj/arm/asm5.go b/src/cmd/internal/obj/arm/asm5.go
index 610637c42edea38388fdd2c2a4343ac5fe050331..12012965b1f940884edc10c82eb1ff6a3b484003 100644 (file)
--- a/src/cmd/internal/obj/arm/asm5.go
+++ b/src/cmd/internal/obj/arm/asm5.go
@@ -188,8 +188,6 @@ var optab = []Optab{
        Optab{AMOVB, C_REG, C_NONE, C_SHIFT, 61, 4, 0, 0, 0},
        Optab{AMOVBS, C_REG, C_NONE, C_SHIFT, 61, 4, 0, 0, 0},
        Optab{AMOVBU, C_REG, C_NONE, C_SHIFT, 61, 4, 0, 0, 0},
-       Optab{ACASE, C_REG, C_NONE, C_NONE, 62, 4, 0, LPCREL, 8},
-       Optab{ABCASE, C_NONE, C_NONE, C_SBRA, 63, 4, 0, LPCREL, 0},
        Optab{AMOVH, C_REG, C_NONE, C_HAUTO, 70, 4, REGSP, 0, 0},
        Optab{AMOVH, C_REG, C_NONE, C_HOREG, 70, 4, 0, 0, 0},
        Optab{AMOVHS, C_REG, C_NONE, C_HAUTO, 70, 4, REGSP, 0, 0},
@@ -274,25 +272,6 @@ var xcmp [C_GOK + 1][C_GOK + 1]uint8
 
 var deferreturn *obj.LSym
 
-/* size of a case statement including jump table */
-func casesz(ctxt *obj.Link, p *obj.Prog) int32 {
-       var jt int = 0
-       var n int32 = 0
-       var o *Optab
-
-       for ; p != nil; p = p.Link {
-               if p.As == ABCASE {
-                       jt = 1
-               } else if jt != 0 {
-                       break
-               }
-               o = oplook(ctxt, p)
-               n += int32(o.size)
-       }
-
-       return n
-}
-
 // Note about encoding: Prog.scond holds the condition encoding,
 // but XOR'ed with C_SCOND_XOR, so that C_SCOND_NONE == 0.
 // The code that shifts the value << 28 has the responsibility
@@ -625,9 +604,6 @@ func span5(ctxt *obj.Link, cursym *obj.LSym) {
                // must check literal pool here in case p generates many instructions
                if ctxt.Blitrl != nil {
                        i = m
-                       if p.As == ACASE {
-                               i = int(casesz(ctxt, p))
-                       }
                        if checkpool(ctxt, op, i) {
                                p = op
                                continue
@@ -1442,8 +1418,6 @@ func buildop(ctxt *obj.Link) {
                        ARFE,
                        obj.ATEXT,
                        obj.AUSEFIELD,
-                       ACASE,
-                       ABCASE,
                        obj.ATYPE:
                        break
 
@@ -2035,39 +2009,6 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
                        o1 |= 1 << 22
                }
 
-       case 62: /* case R -> movw      R<<2(PC),PC */
-               if o.flag&LPCREL != 0 {
-                       o1 = oprrr(ctxt, AADD, int(p.Scond)) | uint32(immrot(1)) | (uint32(p.From.Reg)&15)<<16 | (REGTMP&15)<<12
-                       o2 = olrr(ctxt, REGTMP&15, REGPC, REGTMP, int(p.Scond))
-                       o2 |= 2 << 7
-                       o3 = oprrr(ctxt, AADD, int(p.Scond)) | REGTMP&15 | (REGPC&15)<<16 | (REGPC&15)<<12
-               } else {
-                       o1 = olrr(ctxt, int(p.From.Reg)&15, REGPC, REGPC, int(p.Scond))
-                       o1 |= 2 << 7
-               }
-
-       case 63: /* bcase */
-               if p.Pcond != nil {
-                       rel := obj.Addrel(ctxt.Cursym)
-                       rel.Off = int32(ctxt.Pc)
-                       rel.Siz = 4
-                       if p.To.Sym != nil && p.To.Sym.Type != 0 {
-                               rel.Sym = p.To.Sym
-                               rel.Add = p.To.Offset
-                       } else {
-                               rel.Sym = ctxt.Cursym
-                               rel.Add = p.Pcond.Pc
-                       }
-
-                       if o.flag&LPCREL != 0 {
-                               rel.Type = obj.R_PCREL
-                               rel.Add += ctxt.Pc - p.Rel.Pc - 16 + int64(rel.Siz)
-                       } else {
-                               rel.Type = obj.R_ADDR
-                       }
-                       o1 = 0
-               }
-
                /* reloc ops */
        case 64: /* mov/movb/movbu R,addr */
                o1 = omvl(ctxt, p, &p.To, REGTMP)

diff --git a/src/cmd/internal/obj/arm/obj5.go b/src/cmd/internal/obj/arm/obj5.go
index ae1438f1035127d09a631a7159ff85a6e1a8ac1a..d9f587b08743d73b00f9152658f3bd6fbd9c0da9 100644 (file)
--- a/src/cmd/internal/obj/arm/obj5.go
+++ b/src/cmd/internal/obj/arm/obj5.go
@@ -156,17 +156,6 @@ const (
        LEAF  = 1 << 2
 )
 
-func linkcase(casep *obj.Prog) {
-       for p := casep; p != nil; p = p.Link {
-               if p.As == ABCASE {
-                       for ; p != nil && p.As == ABCASE; p = p.Link {
-                               p.Rel = casep
-                       }
-                       break
-               }
-       }
-}
-
 func preprocess(ctxt *obj.Link, cursym *obj.LSym) {
        autosize := int32(0)
 
@@ -196,11 +185,6 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) {
        var q *obj.Prog
        for p := cursym.Text; p != nil; p = p.Link {
                switch p.As {
-               case ACASE:
-                       if ctxt.Flag_shared != 0 {
-                               linkcase(p)
-                       }
-
                case obj.ATEXT:
                        p.Mark |= LEAF
 
@@ -230,8 +214,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) {
                        cursym.Text.Mark &^= LEAF
                        fallthrough
 
-               case ABCASE,
-                       AB,
+               case AB,
                        ABEQ,
                        ABNE,
                        ABCS,
@@ -914,7 +897,7 @@ loop:
        if p.Pcond != nil {
                if a != ABL && a != ABX && p.Link != nil {
                        q = obj.Brchain(ctxt, p.Link)
-                       if a != obj.ATEXT && a != ABCASE {
+                       if a != obj.ATEXT {
                                if q != nil && (q.Mark&FOLL != 0) {
                                        p.As = int16(relinv(a))
                                        p.Link = p.Pcond