1 // Copyright 2016 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package x86 6 7 import ( 8 "cmd/compile/internal/gc" 9 "cmd/compile/internal/ssa" 10 "cmd/internal/obj" 11 "cmd/internal/obj/x86" 12 "math" 13 ) 14 15 // Generates code for v using 387 instructions. Reports whether 16 // the instruction was handled by this routine. 17 func ssaGenValue387(s *gc.SSAGenState, v *ssa.Value) bool { 18 // The SSA compiler pretends that it has an SSE backend. 19 // If we don't have one of those, we need to translate 20 // all the SSE ops to equivalent 387 ops. That's what this 21 // function does. 22 23 switch v.Op { 24 case ssa.Op386MOVSSconst, ssa.Op386MOVSDconst: 25 p := gc.Prog(loadPush(v.Type)) 26 p.From.Type = obj.TYPE_FCONST 27 p.From.Val = math.Float64frombits(uint64(v.AuxInt)) 28 p.To.Type = obj.TYPE_REG 29 p.To.Reg = x86.REG_F0 30 popAndSave(s, v) 31 return true 32 case ssa.Op386MOVSSconst2, ssa.Op386MOVSDconst2: 33 p := gc.Prog(loadPush(v.Type)) 34 p.From.Type = obj.TYPE_MEM 35 p.From.Reg = v.Args[0].Reg() 36 p.To.Type = obj.TYPE_REG 37 p.To.Reg = x86.REG_F0 38 popAndSave(s, v) 39 return true 40 41 case ssa.Op386MOVSSload, ssa.Op386MOVSDload, ssa.Op386MOVSSloadidx1, ssa.Op386MOVSDloadidx1, ssa.Op386MOVSSloadidx4, ssa.Op386MOVSDloadidx8: 42 p := gc.Prog(loadPush(v.Type)) 43 p.From.Type = obj.TYPE_MEM 44 p.From.Reg = v.Args[0].Reg() 45 gc.AddAux(&p.From, v) 46 switch v.Op { 47 case ssa.Op386MOVSSloadidx1, ssa.Op386MOVSDloadidx1: 48 p.From.Scale = 1 49 p.From.Index = v.Args[1].Reg() 50 case ssa.Op386MOVSSloadidx4: 51 p.From.Scale = 4 52 p.From.Index = v.Args[1].Reg() 53 case ssa.Op386MOVSDloadidx8: 54 p.From.Scale = 8 55 p.From.Index = v.Args[1].Reg() 56 } 57 p.To.Type = obj.TYPE_REG 58 p.To.Reg = x86.REG_F0 59 popAndSave(s, v) 60 return true 61 62 case ssa.Op386MOVSSstore, ssa.Op386MOVSDstore: 63 // Push to-be-stored value on top of stack. 64 push(s, v.Args[1]) 65 66 // Pop and store value. 67 var op obj.As 68 switch v.Op { 69 case ssa.Op386MOVSSstore: 70 op = x86.AFMOVFP 71 case ssa.Op386MOVSDstore: 72 op = x86.AFMOVDP 73 } 74 p := gc.Prog(op) 75 p.From.Type = obj.TYPE_REG 76 p.From.Reg = x86.REG_F0 77 p.To.Type = obj.TYPE_MEM 78 p.To.Reg = v.Args[0].Reg() 79 gc.AddAux(&p.To, v) 80 return true 81 82 case ssa.Op386MOVSSstoreidx1, ssa.Op386MOVSDstoreidx1, ssa.Op386MOVSSstoreidx4, ssa.Op386MOVSDstoreidx8: 83 push(s, v.Args[2]) 84 var op obj.As 85 switch v.Op { 86 case ssa.Op386MOVSSstoreidx1, ssa.Op386MOVSSstoreidx4: 87 op = x86.AFMOVFP 88 case ssa.Op386MOVSDstoreidx1, ssa.Op386MOVSDstoreidx8: 89 op = x86.AFMOVDP 90 } 91 p := gc.Prog(op) 92 p.From.Type = obj.TYPE_REG 93 p.From.Reg = x86.REG_F0 94 p.To.Type = obj.TYPE_MEM 95 p.To.Reg = v.Args[0].Reg() 96 gc.AddAux(&p.To, v) 97 switch v.Op { 98 case ssa.Op386MOVSSstoreidx1, ssa.Op386MOVSDstoreidx1: 99 p.To.Scale = 1 100 p.To.Index = v.Args[1].Reg() 101 case ssa.Op386MOVSSstoreidx4: 102 p.To.Scale = 4 103 p.To.Index = v.Args[1].Reg() 104 case ssa.Op386MOVSDstoreidx8: 105 p.To.Scale = 8 106 p.To.Index = v.Args[1].Reg() 107 } 108 return true 109 110 case ssa.Op386ADDSS, ssa.Op386ADDSD, ssa.Op386SUBSS, ssa.Op386SUBSD, 111 ssa.Op386MULSS, ssa.Op386MULSD, ssa.Op386DIVSS, ssa.Op386DIVSD: 112 if v.Reg() != v.Args[0].Reg() { 113 v.Fatalf("input[0] and output not in same register %s", v.LongString()) 114 } 115 116 // Push arg1 on top of stack 117 push(s, v.Args[1]) 118 119 // Set precision if needed. 64 bits is the default. 120 switch v.Op { 121 case ssa.Op386ADDSS, ssa.Op386SUBSS, ssa.Op386MULSS, ssa.Op386DIVSS: 122 p := gc.Prog(x86.AFSTCW) 123 s.AddrScratch(&p.To) 124 p = gc.Prog(x86.AFLDCW) 125 p.From.Type = obj.TYPE_MEM 126 p.From.Name = obj.NAME_EXTERN 127 p.From.Sym = gc.Linksym(gc.Pkglookup("controlWord32", gc.Runtimepkg)) 128 } 129 130 var op obj.As 131 switch v.Op { 132 case ssa.Op386ADDSS, ssa.Op386ADDSD: 133 op = x86.AFADDDP 134 case ssa.Op386SUBSS, ssa.Op386SUBSD: 135 op = x86.AFSUBDP 136 case ssa.Op386MULSS, ssa.Op386MULSD: 137 op = x86.AFMULDP 138 case ssa.Op386DIVSS, ssa.Op386DIVSD: 139 op = x86.AFDIVDP 140 } 141 p := gc.Prog(op) 142 p.From.Type = obj.TYPE_REG 143 p.From.Reg = x86.REG_F0 144 p.To.Type = obj.TYPE_REG 145 p.To.Reg = s.SSEto387[v.Reg()] + 1 146 147 // Restore precision if needed. 148 switch v.Op { 149 case ssa.Op386ADDSS, ssa.Op386SUBSS, ssa.Op386MULSS, ssa.Op386DIVSS: 150 p := gc.Prog(x86.AFLDCW) 151 s.AddrScratch(&p.From) 152 } 153 154 return true 155 156 case ssa.Op386UCOMISS, ssa.Op386UCOMISD: 157 push(s, v.Args[0]) 158 159 // Compare. 160 p := gc.Prog(x86.AFUCOMP) 161 p.From.Type = obj.TYPE_REG 162 p.From.Reg = x86.REG_F0 163 p.To.Type = obj.TYPE_REG 164 p.To.Reg = s.SSEto387[v.Args[1].Reg()] + 1 165 166 // Save AX. 167 p = gc.Prog(x86.AMOVL) 168 p.From.Type = obj.TYPE_REG 169 p.From.Reg = x86.REG_AX 170 s.AddrScratch(&p.To) 171 172 // Move status word into AX. 173 p = gc.Prog(x86.AFSTSW) 174 p.To.Type = obj.TYPE_REG 175 p.To.Reg = x86.REG_AX 176 177 // Then move the flags we need to the integer flags. 178 gc.Prog(x86.ASAHF) 179 180 // Restore AX. 181 p = gc.Prog(x86.AMOVL) 182 s.AddrScratch(&p.From) 183 p.To.Type = obj.TYPE_REG 184 p.To.Reg = x86.REG_AX 185 186 return true 187 188 case ssa.Op386SQRTSD: 189 push(s, v.Args[0]) 190 gc.Prog(x86.AFSQRT) 191 popAndSave(s, v) 192 return true 193 194 case ssa.Op386FCHS: 195 push(s, v.Args[0]) 196 gc.Prog(x86.AFCHS) 197 popAndSave(s, v) 198 return true 199 200 case ssa.Op386CVTSL2SS, ssa.Op386CVTSL2SD: 201 p := gc.Prog(x86.AMOVL) 202 p.From.Type = obj.TYPE_REG 203 p.From.Reg = v.Args[0].Reg() 204 s.AddrScratch(&p.To) 205 p = gc.Prog(x86.AFMOVL) 206 s.AddrScratch(&p.From) 207 p.To.Type = obj.TYPE_REG 208 p.To.Reg = x86.REG_F0 209 popAndSave(s, v) 210 return true 211 212 case ssa.Op386CVTTSD2SL, ssa.Op386CVTTSS2SL: 213 push(s, v.Args[0]) 214 215 // Save control word. 216 p := gc.Prog(x86.AFSTCW) 217 s.AddrScratch(&p.To) 218 p.To.Offset += 4 219 220 // Load control word which truncates (rounds towards zero). 221 p = gc.Prog(x86.AFLDCW) 222 p.From.Type = obj.TYPE_MEM 223 p.From.Name = obj.NAME_EXTERN 224 p.From.Sym = gc.Linksym(gc.Pkglookup("controlWord64trunc", gc.Runtimepkg)) 225 226 // Now do the conversion. 227 p = gc.Prog(x86.AFMOVLP) 228 p.From.Type = obj.TYPE_REG 229 p.From.Reg = x86.REG_F0 230 s.AddrScratch(&p.To) 231 p = gc.Prog(x86.AMOVL) 232 s.AddrScratch(&p.From) 233 p.To.Type = obj.TYPE_REG 234 p.To.Reg = v.Reg() 235 236 // Restore control word. 237 p = gc.Prog(x86.AFLDCW) 238 s.AddrScratch(&p.From) 239 p.From.Offset += 4 240 return true 241 242 case ssa.Op386CVTSS2SD: 243 // float32 -> float64 is a nop 244 push(s, v.Args[0]) 245 popAndSave(s, v) 246 return true 247 248 case ssa.Op386CVTSD2SS: 249 // Round to nearest float32. 250 push(s, v.Args[0]) 251 p := gc.Prog(x86.AFMOVFP) 252 p.From.Type = obj.TYPE_REG 253 p.From.Reg = x86.REG_F0 254 s.AddrScratch(&p.To) 255 p = gc.Prog(x86.AFMOVF) 256 s.AddrScratch(&p.From) 257 p.To.Type = obj.TYPE_REG 258 p.To.Reg = x86.REG_F0 259 popAndSave(s, v) 260 return true 261 262 case ssa.OpLoadReg: 263 if !v.Type.IsFloat() { 264 return false 265 } 266 // Load+push the value we need. 267 p := gc.Prog(loadPush(v.Type)) 268 gc.AddrAuto(&p.From, v.Args[0]) 269 p.To.Type = obj.TYPE_REG 270 p.To.Reg = x86.REG_F0 271 // Move the value to its assigned register. 272 popAndSave(s, v) 273 return true 274 275 case ssa.OpStoreReg: 276 if !v.Type.IsFloat() { 277 return false 278 } 279 push(s, v.Args[0]) 280 var op obj.As 281 switch v.Type.Size() { 282 case 4: 283 op = x86.AFMOVFP 284 case 8: 285 op = x86.AFMOVDP 286 } 287 p := gc.Prog(op) 288 p.From.Type = obj.TYPE_REG 289 p.From.Reg = x86.REG_F0 290 gc.AddrAuto(&p.To, v) 291 return true 292 293 case ssa.OpCopy: 294 if !v.Type.IsFloat() { 295 return false 296 } 297 push(s, v.Args[0]) 298 popAndSave(s, v) 299 return true 300 301 case ssa.Op386CALLstatic, ssa.Op386CALLclosure, ssa.Op386CALLdefer, ssa.Op386CALLgo, ssa.Op386CALLinter: 302 flush387(s) // Calls must empty the the FP stack. 303 return false // then issue the call as normal 304 } 305 return false 306 } 307 308 // push pushes v onto the floating-point stack. v must be in a register. 309 func push(s *gc.SSAGenState, v *ssa.Value) { 310 p := gc.Prog(x86.AFMOVD) 311 p.From.Type = obj.TYPE_REG 312 p.From.Reg = s.SSEto387[v.Reg()] 313 p.To.Type = obj.TYPE_REG 314 p.To.Reg = x86.REG_F0 315 } 316 317 // popAndSave pops a value off of the floating-point stack and stores 318 // it in the reigster assigned to v. 319 func popAndSave(s *gc.SSAGenState, v *ssa.Value) { 320 r := v.Reg() 321 if _, ok := s.SSEto387[r]; ok { 322 // Pop value, write to correct register. 323 p := gc.Prog(x86.AFMOVDP) 324 p.From.Type = obj.TYPE_REG 325 p.From.Reg = x86.REG_F0 326 p.To.Type = obj.TYPE_REG 327 p.To.Reg = s.SSEto387[v.Reg()] + 1 328 } else { 329 // Don't actually pop value. This 387 register is now the 330 // new home for the not-yet-assigned-a-home SSE register. 331 // Increase the register mapping of all other registers by one. 332 for rSSE, r387 := range s.SSEto387 { 333 s.SSEto387[rSSE] = r387 + 1 334 } 335 s.SSEto387[r] = x86.REG_F0 336 } 337 } 338 339 // loadPush returns the opcode for load+push of the given type. 340 func loadPush(t ssa.Type) obj.As { 341 if t.Size() == 4 { 342 return x86.AFMOVF 343 } 344 return x86.AFMOVD 345 } 346 347 // flush387 removes all entries from the 387 floating-point stack. 348 func flush387(s *gc.SSAGenState) { 349 for k := range s.SSEto387 { 350 p := gc.Prog(x86.AFMOVDP) 351 p.From.Type = obj.TYPE_REG 352 p.From.Reg = x86.REG_F0 353 p.To.Type = obj.TYPE_REG 354 p.To.Reg = x86.REG_F0 355 delete(s.SSEto387, k) 356 } 357 } 358
