Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity
go/src/cmd/asm/internal/arch/arch.go

422 lines
12 KiB
Go
Raw Normal View History

[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package arch
import (
"cmd/internal/obj"
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
"cmd/internal/obj/arm"
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
"cmd/internal/obj/i386" // == 386
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
"cmd/internal/obj/ppc64"
"cmd/internal/obj/x86" // == amd64
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
"fmt"
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
)
// Pseudo-registers whose names are the constant name without the leading R.
const (
RFP = -(iota + 1)
RSB
RSP
RPC
)
// Arch wraps the link architecture object with more architecture-specific information.
type Arch struct {
*obj.LinkArch
// Map of instruction names to enumeration.
Instructions map[string]int
// Map of register names to enumeration.
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
Register map[string]int16
// Table of register prefix names. These are things like R for R(0) and SPR for SPR(268).
RegisterPrefix map[string]bool
// RegisterNumber converts R(10) into arm.REG_R10.
RegisterNumber func(string, int16) (int16, bool)
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
// Instructions that take one operand whose result is a destination.
UnaryDestination map[int]bool
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
// Instruction is a jump.
IsJump func(word string) bool
// Aconv pretty-prints an instruction opcode for this architecture.
Aconv func(int) string
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
}
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
// nilRegisterNumber is the register number function for architectures
// that do not accept the R(N) notation. It always returns failure.
func nilRegisterNumber(name string, n int16) (int16, bool) {
return 0, false
}
[dev.cc] cmd/asm: rewrite to work with new obj API Considerable rewriting of the parser and assembler (code generator) but it's simpler and shorter now. The internal Addr type is gone; so is the package that held it. Parsing of operands goes directly into obj.Addrs now. There is a horrible hack regarding register pairs. It uses the Class field to store the second register since it needs _some_ place to put it but none is provided in the API. An alternative would be nice but this works for now. Once again creates identical .6 and .8 files as the old assembler. Change-Id: I8207d6dfdfdb5bbed0bd870cb34ee0fe61c2fbfd Reviewed-on: https://go-review.googlesource.com/4062 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-06 11:39:23 -08:00
var Pseudos = map[string]int{
"DATA": obj.ADATA,
"FUNCDATA": obj.AFUNCDATA,
"GLOBL": obj.AGLOBL,
"PCDATA": obj.APCDATA,
"TEXT": obj.ATEXT,
}
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
// Set configures the architecture specified by GOARCH and returns its representation.
// It returns nil if GOARCH is not recognized.
func Set(GOARCH string) *Arch {
// TODO: Is this how to set this up?
switch GOARCH {
case "386":
return arch386()
case "amd64":
return archAmd64()
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
case "amd64p32":
a := archAmd64()
a.LinkArch = &x86.Linkamd64p32
return a
case "arm":
return archArm()
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
case "ppc64":
a := archPPC64()
a.LinkArch = &ppc64.Linkppc64
return a
[dev.cc] cmd/asm: add ppc64le support Change-Id: I780ed76c9217d387a73fd7530af2f40948aa1fe4 Reviewed-on: https://go-review.googlesource.com/5452 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 12:23:27 -05:00
case "ppc64le":
a := archPPC64()
a.LinkArch = &ppc64.Linkppc64le
return a
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
}
return nil
}
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
func jump386(word string) bool {
return word[0] == 'J' || word == "CALL"
}
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
func arch386() *Arch {
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
register := make(map[string]int16)
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
// Create maps for easy lookup of instruction names etc.
// TODO: Should this be done in obj for us?
for i, s := range i386.Register {
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
register[s] = int16(i + i386.REG_AL)
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
}
// Pseudo-registers.
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
register["SB"] = RSB
register["FP"] = RFP
register["PC"] = RPC
// Prefixes not used on this architecture.
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
instructions := make(map[string]int)
for i, s := range i386.Anames {
instructions[s] = i
}
// Annoying aliases.
[dev.cc] cmd/asm: make 386 work An editing error prevented the tables from being set up correctly. With that fixed, asm is now compatible with 8a. Change-Id: Ieb20e6dcaf4c05bd448ea748a010ee1f58ef4807 Reviewed-on: https://go-review.googlesource.com/3867 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-04 10:06:06 -08:00
instructions["JA"] = i386.AJHI
instructions["JAE"] = i386.AJCC
instructions["JB"] = i386.AJCS
instructions["JBE"] = i386.AJLS
instructions["JC"] = i386.AJCS
instructions["JE"] = i386.AJEQ
instructions["JG"] = i386.AJGT
instructions["JHS"] = i386.AJCC
instructions["JL"] = i386.AJLT
instructions["JLO"] = i386.AJCS
instructions["JNA"] = i386.AJLS
instructions["JNAE"] = i386.AJCS
instructions["JNB"] = i386.AJCC
instructions["JNBE"] = i386.AJHI
instructions["JNC"] = i386.AJCC
instructions["JNG"] = i386.AJLE
instructions["JNGE"] = i386.AJLT
instructions["JNL"] = i386.AJGE
instructions["JNLE"] = i386.AJGT
instructions["JNO"] = i386.AJOC
instructions["JNP"] = i386.AJPC
instructions["JNS"] = i386.AJPL
instructions["JNZ"] = i386.AJNE
instructions["JO"] = i386.AJOS
instructions["JP"] = i386.AJPS
instructions["JPE"] = i386.AJPS
instructions["JPO"] = i386.AJPC
instructions["JS"] = i386.AJMI
instructions["JZ"] = i386.AJEQ
instructions["MASKMOVDQU"] = i386.AMASKMOVOU
instructions["MOVOA"] = i386.AMOVO
instructions["MOVNTDQ"] = i386.AMOVNTO
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
unaryDestination := make(map[int]bool) // Instruction takes one operand and result is a destination.
// These instructions write to prog.To.
[dev.cc] cmd/asm: make 386 work An editing error prevented the tables from being set up correctly. With that fixed, asm is now compatible with 8a. Change-Id: Ieb20e6dcaf4c05bd448ea748a010ee1f58ef4807 Reviewed-on: https://go-review.googlesource.com/3867 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-04 10:06:06 -08:00
unaryDestination[i386.ABSWAPL] = true
unaryDestination[i386.ACMPXCHG8B] = true
unaryDestination[i386.ADECB] = true
unaryDestination[i386.ADECL] = true
unaryDestination[i386.ADECW] = true
unaryDestination[i386.AINCB] = true
unaryDestination[i386.AINCL] = true
unaryDestination[i386.AINCW] = true
unaryDestination[i386.ANEGB] = true
unaryDestination[i386.ANEGL] = true
unaryDestination[i386.ANEGW] = true
unaryDestination[i386.ANOTB] = true
unaryDestination[i386.ANOTL] = true
unaryDestination[i386.ANOTW] = true
unaryDestination[i386.APOPL] = true
unaryDestination[i386.APOPW] = true
unaryDestination[i386.ASETCC] = true
unaryDestination[i386.ASETCS] = true
unaryDestination[i386.ASETEQ] = true
unaryDestination[i386.ASETGE] = true
unaryDestination[i386.ASETGT] = true
unaryDestination[i386.ASETHI] = true
unaryDestination[i386.ASETLE] = true
unaryDestination[i386.ASETLS] = true
unaryDestination[i386.ASETLT] = true
unaryDestination[i386.ASETMI] = true
unaryDestination[i386.ASETNE] = true
unaryDestination[i386.ASETOC] = true
unaryDestination[i386.ASETOS] = true
unaryDestination[i386.ASETPC] = true
unaryDestination[i386.ASETPL] = true
unaryDestination[i386.ASETPS] = true
unaryDestination[i386.AFFREE] = true
unaryDestination[i386.AFLDENV] = true
unaryDestination[i386.AFSAVE] = true
unaryDestination[i386.AFSTCW] = true
unaryDestination[i386.AFSTENV] = true
unaryDestination[i386.AFSTSW] = true
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
return &Arch{
LinkArch: &i386.Link386,
Instructions: instructions,
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
Register: register,
RegisterPrefix: nil,
RegisterNumber: nilRegisterNumber,
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
UnaryDestination: unaryDestination,
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
IsJump: jump386,
Aconv: i386.Aconv,
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
}
}
func archAmd64() *Arch {
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
register := make(map[string]int16)
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
// Create maps for easy lookup of instruction names etc.
// TODO: Should this be done in obj for us?
for i, s := range x86.Register {
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
register[s] = int16(i + x86.REG_AL)
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
}
// Pseudo-registers.
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
register["SB"] = RSB
register["FP"] = RFP
register["PC"] = RPC
// Register prefix not used on this architecture.
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
instructions := make(map[string]int)
for i, s := range x86.Anames {
instructions[s] = i
}
// Annoying aliases.
cmd/asm: add alias for MOVOA=MOVO on amd64 The alias should exist for both 386 and amd64. There were a few others missing as well. Add them. Change-Id: Ia0c3e71abc79f67a7a66941c0d932a8d5d6e9989 Reviewed-on: https://go-review.googlesource.com/5800 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-24 11:00:07 -08:00
instructions["JA"] = x86.AJHI
instructions["JAE"] = x86.AJCC
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
instructions["JB"] = x86.AJCS
cmd/asm: add alias for MOVOA=MOVO on amd64 The alias should exist for both 386 and amd64. There were a few others missing as well. Add them. Change-Id: Ia0c3e71abc79f67a7a66941c0d932a8d5d6e9989 Reviewed-on: https://go-review.googlesource.com/5800 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-24 11:00:07 -08:00
instructions["JBE"] = x86.AJLS
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
instructions["JC"] = x86.AJCS
instructions["JE"] = x86.AJEQ
cmd/asm: add alias for MOVOA=MOVO on amd64 The alias should exist for both 386 and amd64. There were a few others missing as well. Add them. Change-Id: Ia0c3e71abc79f67a7a66941c0d932a8d5d6e9989 Reviewed-on: https://go-review.googlesource.com/5800 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-24 11:00:07 -08:00
instructions["JG"] = x86.AJGT
instructions["JHS"] = x86.AJCC
instructions["JL"] = x86.AJLT
instructions["JLO"] = x86.AJCS
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
instructions["JNA"] = x86.AJLS
cmd/asm: add alias for MOVOA=MOVO on amd64 The alias should exist for both 386 and amd64. There were a few others missing as well. Add them. Change-Id: Ia0c3e71abc79f67a7a66941c0d932a8d5d6e9989 Reviewed-on: https://go-review.googlesource.com/5800 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-24 11:00:07 -08:00
instructions["JNAE"] = x86.AJCS
instructions["JNB"] = x86.AJCC
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
instructions["JNBE"] = x86.AJHI
cmd/asm: add alias for MOVOA=MOVO on amd64 The alias should exist for both 386 and amd64. There were a few others missing as well. Add them. Change-Id: Ia0c3e71abc79f67a7a66941c0d932a8d5d6e9989 Reviewed-on: https://go-review.googlesource.com/5800 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-24 11:00:07 -08:00
instructions["JNC"] = x86.AJCC
instructions["JNG"] = x86.AJLE
instructions["JNGE"] = x86.AJLT
instructions["JNL"] = x86.AJGE
instructions["JNLE"] = x86.AJGT
cmd/asm: fix build for new aliases Missing leading A on names. Change-Id: I6f3a66bdd3a21220f45a898f0822930b6a7bfa38 Reviewed-on: https://go-review.googlesource.com/5801 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 12:30:39 -08:00
instructions["JNO"] = x86.AJOC
cmd/asm: add alias for MOVOA=MOVO on amd64 The alias should exist for both 386 and amd64. There were a few others missing as well. Add them. Change-Id: Ia0c3e71abc79f67a7a66941c0d932a8d5d6e9989 Reviewed-on: https://go-review.googlesource.com/5800 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-24 11:00:07 -08:00
instructions["JNP"] = x86.AJPC
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
instructions["JNS"] = x86.AJPL
cmd/asm: add alias for MOVOA=MOVO on amd64 The alias should exist for both 386 and amd64. There were a few others missing as well. Add them. Change-Id: Ia0c3e71abc79f67a7a66941c0d932a8d5d6e9989 Reviewed-on: https://go-review.googlesource.com/5800 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-24 11:00:07 -08:00
instructions["JNZ"] = x86.AJNE
cmd/asm: fix build for new aliases Missing leading A on names. Change-Id: I6f3a66bdd3a21220f45a898f0822930b6a7bfa38 Reviewed-on: https://go-review.googlesource.com/5801 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 12:30:39 -08:00
instructions["JO"] = x86.AJOS
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
instructions["JP"] = x86.AJPS
instructions["JPE"] = x86.AJPS
instructions["JPO"] = x86.AJPC
cmd/asm: add alias for MOVOA=MOVO on amd64 The alias should exist for both 386 and amd64. There were a few others missing as well. Add them. Change-Id: Ia0c3e71abc79f67a7a66941c0d932a8d5d6e9989 Reviewed-on: https://go-review.googlesource.com/5800 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-24 11:00:07 -08:00
instructions["JS"] = x86.AJMI
instructions["JZ"] = x86.AJEQ
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
instructions["MASKMOVDQU"] = x86.AMASKMOVOU
instructions["MOVD"] = x86.AMOVQ
instructions["MOVDQ2Q"] = x86.AMOVQ
cmd/asm: fix build for new aliases Missing leading A on names. Change-Id: I6f3a66bdd3a21220f45a898f0822930b6a7bfa38 Reviewed-on: https://go-review.googlesource.com/5801 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 12:30:39 -08:00
instructions["MOVNTDQ"] = x86.AMOVNTO
cmd/asm: add alias for MOVOA=MOVO on amd64 The alias should exist for both 386 and amd64. There were a few others missing as well. Add them. Change-Id: Ia0c3e71abc79f67a7a66941c0d932a8d5d6e9989 Reviewed-on: https://go-review.googlesource.com/5800 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-24 11:00:07 -08:00
instructions["MOVOA"] = x86.AMOVO
cmd/asm: fix build for new aliases Missing leading A on names. Change-Id: I6f3a66bdd3a21220f45a898f0822930b6a7bfa38 Reviewed-on: https://go-review.googlesource.com/5801 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 12:30:39 -08:00
instructions["MOVOA"] = x86.AMOVO
instructions["PF2ID"] = x86.APF2IL
instructions["PI2FD"] = x86.API2FL
instructions["PSLLDQ"] = x86.APSLLO
instructions["PSRLDQ"] = x86.APSRLO
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
unaryDestination := make(map[int]bool) // Instruction takes one operand and result is a destination.
// These instructions write to prog.To.
unaryDestination[x86.ABSWAPL] = true
unaryDestination[x86.ABSWAPQ] = true
unaryDestination[x86.ACMPXCHG8B] = true
unaryDestination[x86.ADECB] = true
unaryDestination[x86.ADECL] = true
unaryDestination[x86.ADECQ] = true
unaryDestination[x86.ADECW] = true
unaryDestination[x86.AINCB] = true
unaryDestination[x86.AINCL] = true
unaryDestination[x86.AINCQ] = true
unaryDestination[x86.AINCW] = true
unaryDestination[x86.ANEGB] = true
unaryDestination[x86.ANEGL] = true
unaryDestination[x86.ANEGQ] = true
unaryDestination[x86.ANEGW] = true
unaryDestination[x86.ANOTB] = true
unaryDestination[x86.ANOTL] = true
unaryDestination[x86.ANOTQ] = true
unaryDestination[x86.ANOTW] = true
unaryDestination[x86.APOPL] = true
unaryDestination[x86.APOPQ] = true
unaryDestination[x86.APOPW] = true
unaryDestination[x86.ASETCC] = true
unaryDestination[x86.ASETCS] = true
unaryDestination[x86.ASETEQ] = true
unaryDestination[x86.ASETGE] = true
unaryDestination[x86.ASETGT] = true
unaryDestination[x86.ASETHI] = true
unaryDestination[x86.ASETLE] = true
unaryDestination[x86.ASETLS] = true
unaryDestination[x86.ASETLT] = true
unaryDestination[x86.ASETMI] = true
unaryDestination[x86.ASETNE] = true
unaryDestination[x86.ASETOC] = true
unaryDestination[x86.ASETOS] = true
unaryDestination[x86.ASETPC] = true
unaryDestination[x86.ASETPL] = true
unaryDestination[x86.ASETPS] = true
unaryDestination[x86.AFFREE] = true
unaryDestination[x86.AFLDENV] = true
unaryDestination[x86.AFSAVE] = true
unaryDestination[x86.AFSTCW] = true
unaryDestination[x86.AFSTENV] = true
unaryDestination[x86.AFSTSW] = true
unaryDestination[x86.AFXSAVE] = true
unaryDestination[x86.AFXSAVE64] = true
unaryDestination[x86.ASTMXCSR] = true
return &Arch{
LinkArch: &x86.Linkamd64,
Instructions: instructions,
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
Register: register,
RegisterPrefix: nil,
RegisterNumber: nilRegisterNumber,
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
UnaryDestination: unaryDestination,
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
IsJump: jump386,
Aconv: x86.Aconv,
}
}
func archArm() *Arch {
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
register := make(map[string]int16)
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
// Create maps for easy lookup of instruction names etc.
// TODO: Should this be done in obj for us?
// Note that there is no list of names as there is for 386 and amd64.
// TODO: Are there aliases we need to add?
for i := arm.REG_R0; i < arm.REG_SPSR; i++ {
cmd/internal/obj: make Rconv a global function Clean up the obj API by making Rconv (register pretty printer) a top-level function. This means that Dconv (operand pretty printer) doesn't need an Rconv argument. To do this, we make the register numbers, which are arbitrary inside an operand (obj.Addr), disjoint sets for each architecture. Each architecture registers (ha) a piece of the space and then the global Rconv knows which architecture-specific printer to use. Clean up all the code that uses Dconv. Now register numbers are large, so a couple of fields in Addr need to go from int8 to int16 because they sometimes hold register numbers. Clean up their uses, which meant regenerating the yacc grammars for the assemblers. There are changes in this CL triggered by earlier changes to yacc, which had not been run in this directory. There is still cleanup to do in Addr, but we're getting closer to that being easy to do. Change-Id: I9290ebee013b62f7d24e886743ea5a6b232990ab Reviewed-on: https://go-review.googlesource.com/6220 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-26 17:09:16 -08:00
register[obj.Rconv(i)] = int16(i)
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
}
// Avoid unintentionally clobbering g using R10.
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
delete(register, "R10")
register["g"] = arm.REG_R10
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
for i := 0; i < 16; i++ {
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
register[fmt.Sprintf("C%d", i)] = int16(i)
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
}
// Pseudo-registers.
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
register["SB"] = RSB
register["FP"] = RFP
register["PC"] = RPC
register["SP"] = RSP
registerPrefix := map[string]bool{
"F": true,
"R": true,
}
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
instructions := make(map[string]int)
for i, s := range arm.Anames {
instructions[s] = i
}
// Annoying aliases.
instructions["B"] = obj.AJMP
instructions["BL"] = obj.ACALL
unaryDestination := make(map[int]bool) // Instruction takes one operand and result is a destination.
// These instructions write to prog.To.
// TODO: These are silly. Fix once C assembler is gone.
unaryDestination[arm.ASWI] = true
unaryDestination[arm.AWORD] = true
return &Arch{
LinkArch: &arm.Linkarm,
Instructions: instructions,
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
Register: register,
RegisterPrefix: registerPrefix,
RegisterNumber: armRegisterNumber,
[dev.cc] cmd/asm: support ARM There are many peculiarites of the ARM architecture that require work: condition codes, new instructions, new instruction arg counts, and more. Rewrite the parser to do a cleaner job, flowing left to right through the sequence of elements of an operand. Add ARM to arch. Add ARM-specific details to the arch in a new file, internal/arch/arm. These are probably better kept away from the "portable" asm. However there are some pieces, like MRC, that are hard to disentangle. They can be cleaned up later. Change-Id: I8c06aedcf61f8a3960a406c094e168182d21b972 Reviewed-on: https://go-review.googlesource.com/4923 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13 17:01:43 -08:00
UnaryDestination: unaryDestination,
IsJump: jumpArm,
Aconv: arm.Aconv,
[dev.cc] cmd/asm: add arch package This package builds the representation of the machine architecture for the new assembler. Almost nothing in it is likely to last but this will get things running. Change-Id: I8edd891f927a81f76d2dbdcd7484b9c87ac0fb2e Reviewed-on: https://go-review.googlesource.com/3194 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-22 10:46:50 -08:00
}
}
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
func archPPC64() *Arch {
register := make(map[string]int16)
// Create maps for easy lookup of instruction names etc.
// TODO: Should this be done in obj for us?
// Note that there is no list of names as there is for 386 and amd64.
for i := ppc64.REG_R0; i <= ppc64.REG_R31; i++ {
cmd/internal/obj: make Rconv a global function Clean up the obj API by making Rconv (register pretty printer) a top-level function. This means that Dconv (operand pretty printer) doesn't need an Rconv argument. To do this, we make the register numbers, which are arbitrary inside an operand (obj.Addr), disjoint sets for each architecture. Each architecture registers (ha) a piece of the space and then the global Rconv knows which architecture-specific printer to use. Clean up all the code that uses Dconv. Now register numbers are large, so a couple of fields in Addr need to go from int8 to int16 because they sometimes hold register numbers. Clean up their uses, which meant regenerating the yacc grammars for the assemblers. There are changes in this CL triggered by earlier changes to yacc, which had not been run in this directory. There is still cleanup to do in Addr, but we're getting closer to that being easy to do. Change-Id: I9290ebee013b62f7d24e886743ea5a6b232990ab Reviewed-on: https://go-review.googlesource.com/6220 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-26 17:09:16 -08:00
register[obj.Rconv(i)] = int16(i)
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
}
for i := ppc64.REG_F0; i <= ppc64.REG_F31; i++ {
cmd/internal/obj: make Rconv a global function Clean up the obj API by making Rconv (register pretty printer) a top-level function. This means that Dconv (operand pretty printer) doesn't need an Rconv argument. To do this, we make the register numbers, which are arbitrary inside an operand (obj.Addr), disjoint sets for each architecture. Each architecture registers (ha) a piece of the space and then the global Rconv knows which architecture-specific printer to use. Clean up all the code that uses Dconv. Now register numbers are large, so a couple of fields in Addr need to go from int8 to int16 because they sometimes hold register numbers. Clean up their uses, which meant regenerating the yacc grammars for the assemblers. There are changes in this CL triggered by earlier changes to yacc, which had not been run in this directory. There is still cleanup to do in Addr, but we're getting closer to that being easy to do. Change-Id: I9290ebee013b62f7d24e886743ea5a6b232990ab Reviewed-on: https://go-review.googlesource.com/6220 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-26 17:09:16 -08:00
register[obj.Rconv(i)] = int16(i)
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
}
for i := ppc64.REG_C0; i <= ppc64.REG_C7; i++ {
// TODO: Rconv prints these as C7 but the input syntax requires CR7.
register[fmt.Sprintf("CR%d", i-ppc64.REG_C0)] = int16(i)
}
for i := ppc64.REG_MSR; i <= ppc64.REG_CR; i++ {
cmd/internal/obj: make Rconv a global function Clean up the obj API by making Rconv (register pretty printer) a top-level function. This means that Dconv (operand pretty printer) doesn't need an Rconv argument. To do this, we make the register numbers, which are arbitrary inside an operand (obj.Addr), disjoint sets for each architecture. Each architecture registers (ha) a piece of the space and then the global Rconv knows which architecture-specific printer to use. Clean up all the code that uses Dconv. Now register numbers are large, so a couple of fields in Addr need to go from int8 to int16 because they sometimes hold register numbers. Clean up their uses, which meant regenerating the yacc grammars for the assemblers. There are changes in this CL triggered by earlier changes to yacc, which had not been run in this directory. There is still cleanup to do in Addr, but we're getting closer to that being easy to do. Change-Id: I9290ebee013b62f7d24e886743ea5a6b232990ab Reviewed-on: https://go-review.googlesource.com/6220 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-26 17:09:16 -08:00
register[obj.Rconv(i)] = int16(i)
[dev.cc] cmd/asm: add ppc64 Fairly straightforward. A couple of unusual addressing tricks. Also added the ability to write R(10) to mean R10. PPC64 uses this for a couple of large register spaces. It appears for ARM now as well, since I saw some uses of that before, although I rewrote them in our source. I could put it in for 386 and amd64 but it's not worth it. Change-Id: I3ffd7ffa62d511b95b92c3c75b9f1d621f5393b6 Reviewed-on: https://go-review.googlesource.com/5282 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-18 20:30:55 -08:00
}
register["CR"] = ppc64.REG_CR
register["XER"] = ppc64.REG_XER
register["LR"] = ppc64.REG_LR
register["CTR"] = ppc64.REG_CTR
register["FPSCR"] = ppc64.REG_FPSCR
register["MSR"] = ppc64.REG_MSR
// Pseudo-registers.
register["SB"] = RSB
register["FP"] = RFP
register["PC"] = RPC
// Avoid unintentionally clobbering g using R30.
delete(register, "R30")
register["g"] = ppc64.REG_R30
registerPrefix := map[string]bool{
"CR": true,
"F": true,
"R": true,
"SPR": true,
}
instructions := make(map[string]int)
for i, s := range ppc64.Anames {
instructions[s] = i
}
// Annoying aliases.
instructions["BR"] = ppc64.ABR
instructions["BL"] = ppc64.ABL
instructions["RETURN"] = ppc64.ARETURN
return &Arch{
LinkArch: &ppc64.Linkppc64,
Instructions: instructions,
Register: register,
RegisterPrefix: registerPrefix,
RegisterNumber: ppc64RegisterNumber,
UnaryDestination: nil,
IsJump: jumpPPC64,
Aconv: ppc64.Aconv,
}
}
Reference in a new issue Copy permalink