| // Derived from Inferno utils/6c/txt.c |
| // http://code.google.com/p/inferno-os/source/browse/utils/6c/txt.c |
| // |
| // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved. |
| // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net) |
| // Portions Copyright © 1997-1999 Vita Nuova Limited |
| // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com) |
| // Portions Copyright © 2004,2006 Bruce Ellis |
| // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net) |
| // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others |
| // Portions Copyright © 2009 The Go Authors. All rights reserved. |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
| // of this software and associated documentation files (the "Software"), to deal |
| // in the Software without restriction, including without limitation the rights |
| // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| // copies of the Software, and to permit persons to whom the Software is |
| // furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| // THE SOFTWARE. |
| |
| package arm64 |
| |
| import ( |
| "cmd/compile/internal/gc" |
| "cmd/internal/obj" |
| "cmd/internal/obj/arm64" |
| "fmt" |
| ) |
| |
| var resvd = []int{ |
| arm64.REGTMP, |
| arm64.REGG, |
| arm64.REGRT1, |
| arm64.REGRT2, |
| arm64.REG_R31, // REGZERO and REGSP |
| arm64.FREGZERO, |
| arm64.FREGHALF, |
| arm64.FREGONE, |
| arm64.FREGTWO, |
| } |
| |
| /* |
| * generate |
| * as $c, n |
| */ |
| func ginscon(as obj.As, c int64, n2 *gc.Node) { |
| var n1 gc.Node |
| |
| gc.Nodconst(&n1, gc.Types[gc.TINT64], c) |
| |
| if as != arm64.AMOVD && (c < -arm64.BIG || c > arm64.BIG) || as == arm64.AMUL || n2 != nil && n2.Op != gc.OREGISTER { |
| // cannot have more than 16-bit of immediate in ADD, etc. |
| // instead, MOV into register first. |
| var ntmp gc.Node |
| gc.Regalloc(&ntmp, gc.Types[gc.TINT64], nil) |
| |
| gins(arm64.AMOVD, &n1, &ntmp) |
| gins(as, &ntmp, n2) |
| gc.Regfree(&ntmp) |
| return |
| } |
| |
| rawgins(as, &n1, n2) |
| } |
| |
| /* |
| * generate |
| * as n, $c (CMP) |
| */ |
| func ginscon2(as obj.As, n2 *gc.Node, c int64) { |
| var n1 gc.Node |
| |
| gc.Nodconst(&n1, gc.Types[gc.TINT64], c) |
| |
| switch as { |
| default: |
| gc.Fatalf("ginscon2") |
| |
| case arm64.ACMP: |
| if -arm64.BIG <= c && c <= arm64.BIG { |
| gcmp(as, n2, &n1) |
| return |
| } |
| } |
| |
| // MOV n1 into register first |
| var ntmp gc.Node |
| gc.Regalloc(&ntmp, gc.Types[gc.TINT64], nil) |
| |
| rawgins(arm64.AMOVD, &n1, &ntmp) |
| gcmp(as, n2, &ntmp) |
| gc.Regfree(&ntmp) |
| } |
| |
| func ginscmp(op gc.Op, t *gc.Type, n1, n2 *gc.Node, likely int) *obj.Prog { |
| if t.IsInteger() && n1.Op == gc.OLITERAL && n2.Op != gc.OLITERAL { |
| // Reverse comparison to place constant last. |
| op = gc.Brrev(op) |
| n1, n2 = n2, n1 |
| } |
| |
| var r1, r2, g1, g2 gc.Node |
| gc.Regalloc(&r1, t, n1) |
| gc.Regalloc(&g1, n1.Type, &r1) |
| gc.Cgen(n1, &g1) |
| gmove(&g1, &r1) |
| if t.IsInteger() && gc.Isconst(n2, gc.CTINT) { |
| ginscon2(optoas(gc.OCMP, t), &r1, n2.Int64()) |
| } else { |
| gc.Regalloc(&r2, t, n2) |
| gc.Regalloc(&g2, n1.Type, &r2) |
| gc.Cgen(n2, &g2) |
| gmove(&g2, &r2) |
| gcmp(optoas(gc.OCMP, t), &r1, &r2) |
| gc.Regfree(&g2) |
| gc.Regfree(&r2) |
| } |
| gc.Regfree(&g1) |
| gc.Regfree(&r1) |
| return gc.Gbranch(optoas(op, t), nil, likely) |
| } |
| |
| /* |
| * generate move: |
| * t = f |
| * hard part is conversions. |
| */ |
| func gmove(f *gc.Node, t *gc.Node) { |
| if gc.Debug['M'] != 0 { |
| fmt.Printf("gmove %v -> %v\n", gc.Nconv(f, gc.FmtLong), gc.Nconv(t, gc.FmtLong)) |
| } |
| |
| ft := int(gc.Simsimtype(f.Type)) |
| tt := int(gc.Simsimtype(t.Type)) |
| cvt := t.Type |
| |
| if gc.Iscomplex[ft] || gc.Iscomplex[tt] { |
| gc.Complexmove(f, t) |
| return |
| } |
| |
| // cannot have two memory operands |
| var r1 gc.Node |
| var a obj.As |
| if gc.Ismem(f) && gc.Ismem(t) { |
| goto hard |
| } |
| |
| // convert constant to desired type |
| if f.Op == gc.OLITERAL { |
| var con gc.Node |
| switch tt { |
| default: |
| f.Convconst(&con, t.Type) |
| |
| case gc.TINT32, |
| gc.TINT16, |
| gc.TINT8: |
| var con gc.Node |
| f.Convconst(&con, gc.Types[gc.TINT64]) |
| var r1 gc.Node |
| gc.Regalloc(&r1, con.Type, t) |
| gins(arm64.AMOVD, &con, &r1) |
| gmove(&r1, t) |
| gc.Regfree(&r1) |
| return |
| |
| case gc.TUINT32, |
| gc.TUINT16, |
| gc.TUINT8: |
| var con gc.Node |
| f.Convconst(&con, gc.Types[gc.TUINT64]) |
| var r1 gc.Node |
| gc.Regalloc(&r1, con.Type, t) |
| gins(arm64.AMOVD, &con, &r1) |
| gmove(&r1, t) |
| gc.Regfree(&r1) |
| return |
| } |
| |
| f = &con |
| ft = tt // so big switch will choose a simple mov |
| |
| // constants can't move directly to memory. |
| if gc.Ismem(t) { |
| goto hard |
| } |
| } |
| |
| // value -> value copy, first operand in memory. |
| // any floating point operand requires register |
| // src, so goto hard to copy to register first. |
| if gc.Ismem(f) && ft != tt && (gc.Isfloat[ft] || gc.Isfloat[tt]) { |
| cvt = gc.Types[ft] |
| goto hard |
| } |
| |
| // value -> value copy, only one memory operand. |
| // figure out the instruction to use. |
| // break out of switch for one-instruction gins. |
| // goto rdst for "destination must be register". |
| // goto hard for "convert to cvt type first". |
| // otherwise handle and return. |
| |
| switch uint32(ft)<<16 | uint32(tt) { |
| default: |
| gc.Fatalf("gmove %v -> %v", gc.Tconv(f.Type, gc.FmtLong), gc.Tconv(t.Type, gc.FmtLong)) |
| |
| /* |
| * integer copy and truncate |
| */ |
| case gc.TINT8<<16 | gc.TINT8, // same size |
| gc.TUINT8<<16 | gc.TINT8, |
| gc.TINT16<<16 | gc.TINT8, |
| // truncate |
| gc.TUINT16<<16 | gc.TINT8, |
| gc.TINT32<<16 | gc.TINT8, |
| gc.TUINT32<<16 | gc.TINT8, |
| gc.TINT64<<16 | gc.TINT8, |
| gc.TUINT64<<16 | gc.TINT8: |
| a = arm64.AMOVB |
| |
| case gc.TINT8<<16 | gc.TUINT8, // same size |
| gc.TUINT8<<16 | gc.TUINT8, |
| gc.TINT16<<16 | gc.TUINT8, |
| // truncate |
| gc.TUINT16<<16 | gc.TUINT8, |
| gc.TINT32<<16 | gc.TUINT8, |
| gc.TUINT32<<16 | gc.TUINT8, |
| gc.TINT64<<16 | gc.TUINT8, |
| gc.TUINT64<<16 | gc.TUINT8: |
| a = arm64.AMOVBU |
| |
| case gc.TINT16<<16 | gc.TINT16, // same size |
| gc.TUINT16<<16 | gc.TINT16, |
| gc.TINT32<<16 | gc.TINT16, |
| // truncate |
| gc.TUINT32<<16 | gc.TINT16, |
| gc.TINT64<<16 | gc.TINT16, |
| gc.TUINT64<<16 | gc.TINT16: |
| a = arm64.AMOVH |
| |
| case gc.TINT16<<16 | gc.TUINT16, // same size |
| gc.TUINT16<<16 | gc.TUINT16, |
| gc.TINT32<<16 | gc.TUINT16, |
| // truncate |
| gc.TUINT32<<16 | gc.TUINT16, |
| gc.TINT64<<16 | gc.TUINT16, |
| gc.TUINT64<<16 | gc.TUINT16: |
| a = arm64.AMOVHU |
| |
| case gc.TINT32<<16 | gc.TINT32, // same size |
| gc.TUINT32<<16 | gc.TINT32, |
| gc.TINT64<<16 | gc.TINT32, |
| // truncate |
| gc.TUINT64<<16 | gc.TINT32: |
| a = arm64.AMOVW |
| |
| case gc.TINT32<<16 | gc.TUINT32, // same size |
| gc.TUINT32<<16 | gc.TUINT32, |
| gc.TINT64<<16 | gc.TUINT32, |
| gc.TUINT64<<16 | gc.TUINT32: |
| a = arm64.AMOVWU |
| |
| case gc.TINT64<<16 | gc.TINT64, // same size |
| gc.TINT64<<16 | gc.TUINT64, |
| gc.TUINT64<<16 | gc.TINT64, |
| gc.TUINT64<<16 | gc.TUINT64: |
| a = arm64.AMOVD |
| |
| /* |
| * integer up-conversions |
| */ |
| case gc.TINT8<<16 | gc.TINT16, // sign extend int8 |
| gc.TINT8<<16 | gc.TUINT16, |
| gc.TINT8<<16 | gc.TINT32, |
| gc.TINT8<<16 | gc.TUINT32, |
| gc.TINT8<<16 | gc.TINT64, |
| gc.TINT8<<16 | gc.TUINT64: |
| a = arm64.AMOVB |
| |
| goto rdst |
| |
| case gc.TUINT8<<16 | gc.TINT16, // zero extend uint8 |
| gc.TUINT8<<16 | gc.TUINT16, |
| gc.TUINT8<<16 | gc.TINT32, |
| gc.TUINT8<<16 | gc.TUINT32, |
| gc.TUINT8<<16 | gc.TINT64, |
| gc.TUINT8<<16 | gc.TUINT64: |
| a = arm64.AMOVBU |
| |
| goto rdst |
| |
| case gc.TINT16<<16 | gc.TINT32, // sign extend int16 |
| gc.TINT16<<16 | gc.TUINT32, |
| gc.TINT16<<16 | gc.TINT64, |
| gc.TINT16<<16 | gc.TUINT64: |
| a = arm64.AMOVH |
| |
| goto rdst |
| |
| case gc.TUINT16<<16 | gc.TINT32, // zero extend uint16 |
| gc.TUINT16<<16 | gc.TUINT32, |
| gc.TUINT16<<16 | gc.TINT64, |
| gc.TUINT16<<16 | gc.TUINT64: |
| a = arm64.AMOVHU |
| |
| goto rdst |
| |
| case gc.TINT32<<16 | gc.TINT64, // sign extend int32 |
| gc.TINT32<<16 | gc.TUINT64: |
| a = arm64.AMOVW |
| |
| goto rdst |
| |
| case gc.TUINT32<<16 | gc.TINT64, // zero extend uint32 |
| gc.TUINT32<<16 | gc.TUINT64: |
| a = arm64.AMOVWU |
| |
| goto rdst |
| |
| /* |
| * float to integer |
| */ |
| case gc.TFLOAT32<<16 | gc.TINT32: |
| a = arm64.AFCVTZSSW |
| goto rdst |
| |
| case gc.TFLOAT64<<16 | gc.TINT32: |
| a = arm64.AFCVTZSDW |
| goto rdst |
| |
| case gc.TFLOAT32<<16 | gc.TINT64: |
| a = arm64.AFCVTZSS |
| goto rdst |
| |
| case gc.TFLOAT64<<16 | gc.TINT64: |
| a = arm64.AFCVTZSD |
| goto rdst |
| |
| case gc.TFLOAT32<<16 | gc.TUINT32: |
| a = arm64.AFCVTZUSW |
| goto rdst |
| |
| case gc.TFLOAT64<<16 | gc.TUINT32: |
| a = arm64.AFCVTZUDW |
| goto rdst |
| |
| case gc.TFLOAT32<<16 | gc.TUINT64: |
| a = arm64.AFCVTZUS |
| goto rdst |
| |
| case gc.TFLOAT64<<16 | gc.TUINT64: |
| a = arm64.AFCVTZUD |
| goto rdst |
| |
| case gc.TFLOAT32<<16 | gc.TINT16, |
| gc.TFLOAT32<<16 | gc.TINT8, |
| gc.TFLOAT64<<16 | gc.TINT16, |
| gc.TFLOAT64<<16 | gc.TINT8: |
| cvt = gc.Types[gc.TINT32] |
| |
| goto hard |
| |
| case gc.TFLOAT32<<16 | gc.TUINT16, |
| gc.TFLOAT32<<16 | gc.TUINT8, |
| gc.TFLOAT64<<16 | gc.TUINT16, |
| gc.TFLOAT64<<16 | gc.TUINT8: |
| cvt = gc.Types[gc.TUINT32] |
| |
| goto hard |
| |
| /* |
| * integer to float |
| */ |
| case gc.TINT8<<16 | gc.TFLOAT32, |
| gc.TINT16<<16 | gc.TFLOAT32, |
| gc.TINT32<<16 | gc.TFLOAT32: |
| a = arm64.ASCVTFWS |
| |
| goto rdst |
| |
| case gc.TINT8<<16 | gc.TFLOAT64, |
| gc.TINT16<<16 | gc.TFLOAT64, |
| gc.TINT32<<16 | gc.TFLOAT64: |
| a = arm64.ASCVTFWD |
| |
| goto rdst |
| |
| case gc.TINT64<<16 | gc.TFLOAT32: |
| a = arm64.ASCVTFS |
| goto rdst |
| |
| case gc.TINT64<<16 | gc.TFLOAT64: |
| a = arm64.ASCVTFD |
| goto rdst |
| |
| case gc.TUINT8<<16 | gc.TFLOAT32, |
| gc.TUINT16<<16 | gc.TFLOAT32, |
| gc.TUINT32<<16 | gc.TFLOAT32: |
| a = arm64.AUCVTFWS |
| |
| goto rdst |
| |
| case gc.TUINT8<<16 | gc.TFLOAT64, |
| gc.TUINT16<<16 | gc.TFLOAT64, |
| gc.TUINT32<<16 | gc.TFLOAT64: |
| a = arm64.AUCVTFWD |
| |
| goto rdst |
| |
| case gc.TUINT64<<16 | gc.TFLOAT32: |
| a = arm64.AUCVTFS |
| goto rdst |
| |
| case gc.TUINT64<<16 | gc.TFLOAT64: |
| a = arm64.AUCVTFD |
| goto rdst |
| |
| /* |
| * float to float |
| */ |
| case gc.TFLOAT32<<16 | gc.TFLOAT32: |
| a = arm64.AFMOVS |
| |
| case gc.TFLOAT64<<16 | gc.TFLOAT64: |
| a = arm64.AFMOVD |
| |
| case gc.TFLOAT32<<16 | gc.TFLOAT64: |
| a = arm64.AFCVTSD |
| goto rdst |
| |
| case gc.TFLOAT64<<16 | gc.TFLOAT32: |
| a = arm64.AFCVTDS |
| goto rdst |
| } |
| |
| gins(a, f, t) |
| return |
| |
| // requires register destination |
| rdst: |
| gc.Regalloc(&r1, t.Type, t) |
| |
| gins(a, f, &r1) |
| gmove(&r1, t) |
| gc.Regfree(&r1) |
| return |
| |
| // requires register intermediate |
| hard: |
| gc.Regalloc(&r1, cvt, t) |
| |
| gmove(f, &r1) |
| gmove(&r1, t) |
| gc.Regfree(&r1) |
| return |
| } |
| |
| // gins is called by the front end. |
| // It synthesizes some multiple-instruction sequences |
| // so the front end can stay simpler. |
| func gins(as obj.As, f, t *gc.Node) *obj.Prog { |
| if as >= obj.A_ARCHSPECIFIC { |
| if x, ok := f.IntLiteral(); ok { |
| ginscon(as, x, t) |
| return nil // caller must not use |
| } |
| } |
| if as == arm64.ACMP { |
| if x, ok := t.IntLiteral(); ok { |
| ginscon2(as, f, x) |
| return nil // caller must not use |
| } |
| } |
| return rawgins(as, f, t) |
| } |
| |
| /* |
| * generate one instruction: |
| * as f, t |
| */ |
| func rawgins(as obj.As, f *gc.Node, t *gc.Node) *obj.Prog { |
| // TODO(austin): Add self-move test like in 6g (but be careful |
| // of truncation moves) |
| |
| p := gc.Prog(as) |
| gc.Naddr(&p.From, f) |
| gc.Naddr(&p.To, t) |
| |
| switch as { |
| case arm64.ACMP, arm64.AFCMPS, arm64.AFCMPD: |
| if t != nil { |
| if f.Op != gc.OREGISTER { |
| gc.Fatalf("bad operands to gcmp") |
| } |
| p.From = p.To |
| p.To = obj.Addr{} |
| raddr(f, p) |
| } |
| } |
| |
| // Bad things the front end has done to us. Crash to find call stack. |
| switch as { |
| case arm64.AAND, arm64.AMUL: |
| if p.From.Type == obj.TYPE_CONST { |
| gc.Debug['h'] = 1 |
| gc.Fatalf("bad inst: %v", p) |
| } |
| case arm64.ACMP: |
| if p.From.Type == obj.TYPE_MEM || p.To.Type == obj.TYPE_MEM { |
| gc.Debug['h'] = 1 |
| gc.Fatalf("bad inst: %v", p) |
| } |
| } |
| |
| if gc.Debug['g'] != 0 { |
| fmt.Printf("%v\n", p) |
| } |
| |
| w := int32(0) |
| switch as { |
| case arm64.AMOVB, |
| arm64.AMOVBU: |
| w = 1 |
| |
| case arm64.AMOVH, |
| arm64.AMOVHU: |
| w = 2 |
| |
| case arm64.AMOVW, |
| arm64.AMOVWU: |
| w = 4 |
| |
| case arm64.AMOVD: |
| if p.From.Type == obj.TYPE_CONST || p.From.Type == obj.TYPE_ADDR { |
| break |
| } |
| w = 8 |
| } |
| |
| if w != 0 && ((f != nil && p.From.Width < int64(w)) || (t != nil && p.To.Type != obj.TYPE_REG && p.To.Width > int64(w))) { |
| gc.Dump("f", f) |
| gc.Dump("t", t) |
| gc.Fatalf("bad width: %v (%d, %d)\n", p, p.From.Width, p.To.Width) |
| } |
| |
| return p |
| } |
| |
| /* |
| * insert n into reg slot of p |
| */ |
| func raddr(n *gc.Node, p *obj.Prog) { |
| var a obj.Addr |
| |
| gc.Naddr(&a, n) |
| if a.Type != obj.TYPE_REG { |
| if n != nil { |
| gc.Fatalf("bad in raddr: %v", n.Op) |
| } else { |
| gc.Fatalf("bad in raddr: <null>") |
| } |
| p.Reg = 0 |
| } else { |
| p.Reg = a.Reg |
| } |
| } |
| |
| func gcmp(as obj.As, lhs *gc.Node, rhs *gc.Node) *obj.Prog { |
| if lhs.Op != gc.OREGISTER { |
| gc.Fatalf("bad operands to gcmp: %v %v", lhs.Op, rhs.Op) |
| } |
| |
| p := rawgins(as, rhs, nil) |
| raddr(lhs, p) |
| return p |
| } |
| |
| /* |
| * return Axxx for Oxxx on type t. |
| */ |
| func optoas(op gc.Op, t *gc.Type) obj.As { |
| if t == nil { |
| gc.Fatalf("optoas: t is nil") |
| } |
| |
| // avoid constant conversions in switches below |
| const ( |
| OMINUS_ = uint32(gc.OMINUS) << 16 |
| OLSH_ = uint32(gc.OLSH) << 16 |
| ORSH_ = uint32(gc.ORSH) << 16 |
| OADD_ = uint32(gc.OADD) << 16 |
| OSUB_ = uint32(gc.OSUB) << 16 |
| OMUL_ = uint32(gc.OMUL) << 16 |
| ODIV_ = uint32(gc.ODIV) << 16 |
| OOR_ = uint32(gc.OOR) << 16 |
| OAND_ = uint32(gc.OAND) << 16 |
| OXOR_ = uint32(gc.OXOR) << 16 |
| OEQ_ = uint32(gc.OEQ) << 16 |
| ONE_ = uint32(gc.ONE) << 16 |
| OLT_ = uint32(gc.OLT) << 16 |
| OLE_ = uint32(gc.OLE) << 16 |
| OGE_ = uint32(gc.OGE) << 16 |
| OGT_ = uint32(gc.OGT) << 16 |
| OCMP_ = uint32(gc.OCMP) << 16 |
| OAS_ = uint32(gc.OAS) << 16 |
| OHMUL_ = uint32(gc.OHMUL) << 16 |
| OSQRT_ = uint32(gc.OSQRT) << 16 |
| ) |
| |
| a := obj.AXXX |
| switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) { |
| default: |
| gc.Fatalf("optoas: no entry for op=%v type=%v", op, t) |
| |
| case OEQ_ | gc.TBOOL, |
| OEQ_ | gc.TINT8, |
| OEQ_ | gc.TUINT8, |
| OEQ_ | gc.TINT16, |
| OEQ_ | gc.TUINT16, |
| OEQ_ | gc.TINT32, |
| OEQ_ | gc.TUINT32, |
| OEQ_ | gc.TINT64, |
| OEQ_ | gc.TUINT64, |
| OEQ_ | gc.TPTR32, |
| OEQ_ | gc.TPTR64, |
| OEQ_ | gc.TFLOAT32, |
| OEQ_ | gc.TFLOAT64: |
| a = arm64.ABEQ |
| |
| case ONE_ | gc.TBOOL, |
| ONE_ | gc.TINT8, |
| ONE_ | gc.TUINT8, |
| ONE_ | gc.TINT16, |
| ONE_ | gc.TUINT16, |
| ONE_ | gc.TINT32, |
| ONE_ | gc.TUINT32, |
| ONE_ | gc.TINT64, |
| ONE_ | gc.TUINT64, |
| ONE_ | gc.TPTR32, |
| ONE_ | gc.TPTR64, |
| ONE_ | gc.TFLOAT32, |
| ONE_ | gc.TFLOAT64: |
| a = arm64.ABNE |
| |
| case OLT_ | gc.TINT8, |
| OLT_ | gc.TINT16, |
| OLT_ | gc.TINT32, |
| OLT_ | gc.TINT64: |
| a = arm64.ABLT |
| |
| case OLT_ | gc.TUINT8, |
| OLT_ | gc.TUINT16, |
| OLT_ | gc.TUINT32, |
| OLT_ | gc.TUINT64, |
| OLT_ | gc.TFLOAT32, |
| OLT_ | gc.TFLOAT64: |
| a = arm64.ABLO |
| |
| case OLE_ | gc.TINT8, |
| OLE_ | gc.TINT16, |
| OLE_ | gc.TINT32, |
| OLE_ | gc.TINT64: |
| a = arm64.ABLE |
| |
| case OLE_ | gc.TUINT8, |
| OLE_ | gc.TUINT16, |
| OLE_ | gc.TUINT32, |
| OLE_ | gc.TUINT64, |
| OLE_ | gc.TFLOAT32, |
| OLE_ | gc.TFLOAT64: |
| a = arm64.ABLS |
| |
| case OGT_ | gc.TINT8, |
| OGT_ | gc.TINT16, |
| OGT_ | gc.TINT32, |
| OGT_ | gc.TINT64, |
| OGT_ | gc.TFLOAT32, |
| OGT_ | gc.TFLOAT64: |
| a = arm64.ABGT |
| |
| case OGT_ | gc.TUINT8, |
| OGT_ | gc.TUINT16, |
| OGT_ | gc.TUINT32, |
| OGT_ | gc.TUINT64: |
| a = arm64.ABHI |
| |
| case OGE_ | gc.TINT8, |
| OGE_ | gc.TINT16, |
| OGE_ | gc.TINT32, |
| OGE_ | gc.TINT64, |
| OGE_ | gc.TFLOAT32, |
| OGE_ | gc.TFLOAT64: |
| a = arm64.ABGE |
| |
| case OGE_ | gc.TUINT8, |
| OGE_ | gc.TUINT16, |
| OGE_ | gc.TUINT32, |
| OGE_ | gc.TUINT64: |
| a = arm64.ABHS |
| |
| case OCMP_ | gc.TBOOL, |
| OCMP_ | gc.TINT8, |
| OCMP_ | gc.TINT16, |
| OCMP_ | gc.TINT32, |
| OCMP_ | gc.TPTR32, |
| OCMP_ | gc.TINT64, |
| OCMP_ | gc.TUINT8, |
| OCMP_ | gc.TUINT16, |
| OCMP_ | gc.TUINT32, |
| OCMP_ | gc.TUINT64, |
| OCMP_ | gc.TPTR64: |
| a = arm64.ACMP |
| |
| case OCMP_ | gc.TFLOAT32: |
| a = arm64.AFCMPS |
| |
| case OCMP_ | gc.TFLOAT64: |
| a = arm64.AFCMPD |
| |
| case OAS_ | gc.TBOOL, |
| OAS_ | gc.TINT8: |
| a = arm64.AMOVB |
| |
| case OAS_ | gc.TUINT8: |
| a = arm64.AMOVBU |
| |
| case OAS_ | gc.TINT16: |
| a = arm64.AMOVH |
| |
| case OAS_ | gc.TUINT16: |
| a = arm64.AMOVHU |
| |
| case OAS_ | gc.TINT32: |
| a = arm64.AMOVW |
| |
| case OAS_ | gc.TUINT32, |
| OAS_ | gc.TPTR32: |
| a = arm64.AMOVWU |
| |
| case OAS_ | gc.TINT64, |
| OAS_ | gc.TUINT64, |
| OAS_ | gc.TPTR64: |
| a = arm64.AMOVD |
| |
| case OAS_ | gc.TFLOAT32: |
| a = arm64.AFMOVS |
| |
| case OAS_ | gc.TFLOAT64: |
| a = arm64.AFMOVD |
| |
| case OADD_ | gc.TINT8, |
| OADD_ | gc.TUINT8, |
| OADD_ | gc.TINT16, |
| OADD_ | gc.TUINT16, |
| OADD_ | gc.TINT32, |
| OADD_ | gc.TUINT32, |
| OADD_ | gc.TPTR32, |
| OADD_ | gc.TINT64, |
| OADD_ | gc.TUINT64, |
| OADD_ | gc.TPTR64: |
| a = arm64.AADD |
| |
| case OADD_ | gc.TFLOAT32: |
| a = arm64.AFADDS |
| |
| case OADD_ | gc.TFLOAT64: |
| a = arm64.AFADDD |
| |
| case OSUB_ | gc.TINT8, |
| OSUB_ | gc.TUINT8, |
| OSUB_ | gc.TINT16, |
| OSUB_ | gc.TUINT16, |
| OSUB_ | gc.TINT32, |
| OSUB_ | gc.TUINT32, |
| OSUB_ | gc.TPTR32, |
| OSUB_ | gc.TINT64, |
| OSUB_ | gc.TUINT64, |
| OSUB_ | gc.TPTR64: |
| a = arm64.ASUB |
| |
| case OSUB_ | gc.TFLOAT32: |
| a = arm64.AFSUBS |
| |
| case OSUB_ | gc.TFLOAT64: |
| a = arm64.AFSUBD |
| |
| case OMINUS_ | gc.TINT8, |
| OMINUS_ | gc.TUINT8, |
| OMINUS_ | gc.TINT16, |
| OMINUS_ | gc.TUINT16, |
| OMINUS_ | gc.TINT32, |
| OMINUS_ | gc.TUINT32, |
| OMINUS_ | gc.TPTR32, |
| OMINUS_ | gc.TINT64, |
| OMINUS_ | gc.TUINT64, |
| OMINUS_ | gc.TPTR64: |
| a = arm64.ANEG |
| |
| case OMINUS_ | gc.TFLOAT32: |
| a = arm64.AFNEGS |
| |
| case OMINUS_ | gc.TFLOAT64: |
| a = arm64.AFNEGD |
| |
| case OAND_ | gc.TINT8, |
| OAND_ | gc.TUINT8, |
| OAND_ | gc.TINT16, |
| OAND_ | gc.TUINT16, |
| OAND_ | gc.TINT32, |
| OAND_ | gc.TUINT32, |
| OAND_ | gc.TPTR32, |
| OAND_ | gc.TINT64, |
| OAND_ | gc.TUINT64, |
| OAND_ | gc.TPTR64: |
| a = arm64.AAND |
| |
| case OOR_ | gc.TINT8, |
| OOR_ | gc.TUINT8, |
| OOR_ | gc.TINT16, |
| OOR_ | gc.TUINT16, |
| OOR_ | gc.TINT32, |
| OOR_ | gc.TUINT32, |
| OOR_ | gc.TPTR32, |
| OOR_ | gc.TINT64, |
| OOR_ | gc.TUINT64, |
| OOR_ | gc.TPTR64: |
| a = arm64.AORR |
| |
| case OXOR_ | gc.TINT8, |
| OXOR_ | gc.TUINT8, |
| OXOR_ | gc.TINT16, |
| OXOR_ | gc.TUINT16, |
| OXOR_ | gc.TINT32, |
| OXOR_ | gc.TUINT32, |
| OXOR_ | gc.TPTR32, |
| OXOR_ | gc.TINT64, |
| OXOR_ | gc.TUINT64, |
| OXOR_ | gc.TPTR64: |
| a = arm64.AEOR |
| |
| // TODO(minux): handle rotates |
| //case CASE(OLROT, TINT8): |
| //case CASE(OLROT, TUINT8): |
| //case CASE(OLROT, TINT16): |
| //case CASE(OLROT, TUINT16): |
| //case CASE(OLROT, TINT32): |
| //case CASE(OLROT, TUINT32): |
| //case CASE(OLROT, TPTR32): |
| //case CASE(OLROT, TINT64): |
| //case CASE(OLROT, TUINT64): |
| //case CASE(OLROT, TPTR64): |
| // a = 0//???; RLDC? |
| // break; |
| |
| case OLSH_ | gc.TINT8, |
| OLSH_ | gc.TUINT8, |
| OLSH_ | gc.TINT16, |
| OLSH_ | gc.TUINT16, |
| OLSH_ | gc.TINT32, |
| OLSH_ | gc.TUINT32, |
| OLSH_ | gc.TPTR32, |
| OLSH_ | gc.TINT64, |
| OLSH_ | gc.TUINT64, |
| OLSH_ | gc.TPTR64: |
| a = arm64.ALSL |
| |
| case ORSH_ | gc.TUINT8, |
| ORSH_ | gc.TUINT16, |
| ORSH_ | gc.TUINT32, |
| ORSH_ | gc.TPTR32, |
| ORSH_ | gc.TUINT64, |
| ORSH_ | gc.TPTR64: |
| a = arm64.ALSR |
| |
| case ORSH_ | gc.TINT8, |
| ORSH_ | gc.TINT16, |
| ORSH_ | gc.TINT32, |
| ORSH_ | gc.TINT64: |
| a = arm64.AASR |
| |
| case OHMUL_ | gc.TINT64: |
| a = arm64.ASMULH |
| |
| case OHMUL_ | gc.TUINT64, |
| OHMUL_ | gc.TPTR64: |
| a = arm64.AUMULH |
| |
| case OMUL_ | gc.TINT8, |
| OMUL_ | gc.TINT16, |
| OMUL_ | gc.TINT32: |
| a = arm64.ASMULL |
| |
| case OMUL_ | gc.TINT64: |
| a = arm64.AMUL |
| |
| case OMUL_ | gc.TUINT8, |
| OMUL_ | gc.TUINT16, |
| OMUL_ | gc.TUINT32, |
| OMUL_ | gc.TPTR32: |
| // don't use word multiply, the high 32-bit are undefined. |
| a = arm64.AUMULL |
| |
| case OMUL_ | gc.TUINT64, |
| OMUL_ | gc.TPTR64: |
| a = arm64.AMUL // for 64-bit multiplies, signedness doesn't matter. |
| |
| case OMUL_ | gc.TFLOAT32: |
| a = arm64.AFMULS |
| |
| case OMUL_ | gc.TFLOAT64: |
| a = arm64.AFMULD |
| |
| case ODIV_ | gc.TINT8, |
| ODIV_ | gc.TINT16, |
| ODIV_ | gc.TINT32, |
| ODIV_ | gc.TINT64: |
| a = arm64.ASDIV |
| |
| case ODIV_ | gc.TUINT8, |
| ODIV_ | gc.TUINT16, |
| ODIV_ | gc.TUINT32, |
| ODIV_ | gc.TPTR32, |
| ODIV_ | gc.TUINT64, |
| ODIV_ | gc.TPTR64: |
| a = arm64.AUDIV |
| |
| case ODIV_ | gc.TFLOAT32: |
| a = arm64.AFDIVS |
| |
| case ODIV_ | gc.TFLOAT64: |
| a = arm64.AFDIVD |
| |
| case OSQRT_ | gc.TFLOAT64: |
| a = arm64.AFSQRTD |
| } |
| |
| return a |
| } |
| |
| const ( |
| ODynam = 1 << 0 |
| OAddable = 1 << 1 |
| ) |
| |
| func xgen(n *gc.Node, a *gc.Node, o int) bool { |
| // TODO(minux) |
| |
| return -1 != 0 /*TypeKind(100016)*/ |
| } |
| |
| func sudoclean() { |
| return |
| } |
| |
| /* |
| * generate code to compute address of n, |
| * a reference to a (perhaps nested) field inside |
| * an array or struct. |
| * return 0 on failure, 1 on success. |
| * on success, leaves usable address in a. |
| * |
| * caller is responsible for calling sudoclean |
| * after successful sudoaddable, |
| * to release the register used for a. |
| */ |
| func sudoaddable(as obj.As, n *gc.Node, a *obj.Addr) bool { |
| // TODO(minux) |
| |
| *a = obj.Addr{} |
| return false |
| } |
