arm.go

     1  // Copyright 2015 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  // This file encapsulates some of the odd characteristics of the ARM
     6  // instruction set, to minimize its interaction with the core of the
     7  // assembler.
     8  
     9  package arch
    10  
    11  import (
    12  	"strings"
    13  
    14  	"cmd/internal/obj"
    15  	"cmd/internal/obj/arm"
    16  )
    17  
    18  var armLS = map[string]uint8{
    19  	"U":  arm.C_UBIT,
    20  	"S":  arm.C_SBIT,
    21  	"W":  arm.C_WBIT,
    22  	"P":  arm.C_PBIT,
    23  	"PW": arm.C_WBIT | arm.C_PBIT,
    24  	"WP": arm.C_WBIT | arm.C_PBIT,
    25  }
    26  
    27  var armSCOND = map[string]uint8{
    28  	"EQ":  arm.C_SCOND_EQ,
    29  	"NE":  arm.C_SCOND_NE,
    30  	"CS":  arm.C_SCOND_HS,
    31  	"HS":  arm.C_SCOND_HS,
    32  	"CC":  arm.C_SCOND_LO,
    33  	"LO":  arm.C_SCOND_LO,
    34  	"MI":  arm.C_SCOND_MI,
    35  	"PL":  arm.C_SCOND_PL,
    36  	"VS":  arm.C_SCOND_VS,
    37  	"VC":  arm.C_SCOND_VC,
    38  	"HI":  arm.C_SCOND_HI,
    39  	"LS":  arm.C_SCOND_LS,
    40  	"GE":  arm.C_SCOND_GE,
    41  	"LT":  arm.C_SCOND_LT,
    42  	"GT":  arm.C_SCOND_GT,
    43  	"LE":  arm.C_SCOND_LE,
    44  	"AL":  arm.C_SCOND_NONE,
    45  	"U":   arm.C_UBIT,
    46  	"S":   arm.C_SBIT,
    47  	"W":   arm.C_WBIT,
    48  	"P":   arm.C_PBIT,
    49  	"PW":  arm.C_WBIT | arm.C_PBIT,
    50  	"WP":  arm.C_WBIT | arm.C_PBIT,
    51  	"F":   arm.C_FBIT,
    52  	"IBW": arm.C_WBIT | arm.C_PBIT | arm.C_UBIT,
    53  	"IAW": arm.C_WBIT | arm.C_UBIT,
    54  	"DBW": arm.C_WBIT | arm.C_PBIT,
    55  	"DAW": arm.C_WBIT,
    56  	"IB":  arm.C_PBIT | arm.C_UBIT,
    57  	"IA":  arm.C_UBIT,
    58  	"DB":  arm.C_PBIT,
    59  	"DA":  0,
    60  }
    61  
    62  var armJump = map[string]bool{
    63  	"B":    true,
    64  	"BL":   true,
    65  	"BX":   true,
    66  	"BEQ":  true,
    67  	"BNE":  true,
    68  	"BCS":  true,
    69  	"BHS":  true,
    70  	"BCC":  true,
    71  	"BLO":  true,
    72  	"BMI":  true,
    73  	"BPL":  true,
    74  	"BVS":  true,
    75  	"BVC":  true,
    76  	"BHI":  true,
    77  	"BLS":  true,
    78  	"BGE":  true,
    79  	"BLT":  true,
    80  	"BGT":  true,
    81  	"BLE":  true,
    82  	"CALL": true,
    83  	"JMP":  true,
    84  }
    85  
    86  func jumpArm(word string) bool {
    87  	return armJump[word]
    88  }
    89  
    90  // IsARMCMP reports whether the op (as defined by an arm.A* constant) is
    91  // one of the comparison instructions that require special handling.
    92  func IsARMCMP(op obj.As) bool {
    93  	switch op {
    94  	case arm.ACMN, arm.ACMP, arm.ATEQ, arm.ATST:
    95  		return true
    96  	}
    97  	return false
    98  }
    99  
   100  // IsARMSTREX reports whether the op (as defined by an arm.A* constant) is
   101  // one of the STREX-like instructions that require special handling.
   102  func IsARMSTREX(op obj.As) bool {
   103  	switch op {
   104  	case arm.ASTREX, arm.ASTREXD, arm.ASWPW, arm.ASWPBU:
   105  		return true
   106  	}
   107  	return false
   108  }
   109  
   110  // MCR is not defined by the obj/arm; instead we define it privately here.
   111  // It is encoded as an MRC with a bit inside the instruction word,
   112  // passed to arch.ARMMRCOffset.
   113  const aMCR = arm.ALAST + 1
   114  
   115  // IsARMMRC reports whether the op (as defined by an arm.A* constant) is
   116  // MRC or MCR.
   117  func IsARMMRC(op obj.As) bool {
   118  	switch op {
   119  	case arm.AMRC, aMCR: // Note: aMCR is defined in this package.
   120  		return true
   121  	}
   122  	return false
   123  }
   124  
   125  // IsARMBFX reports whether the op (as defined by an arm.A* constant) is one the
   126  // BFX-like instructions which are in the form of "op $width, $LSB, (Reg,) Reg".
   127  func IsARMBFX(op obj.As) bool {
   128  	switch op {
   129  	case arm.ABFX, arm.ABFXU, arm.ABFC, arm.ABFI:
   130  		return true
   131  	}
   132  	return false
   133  }
   134  
   135  // IsARMFloatCmp reports whether the op is a floating comparison instruction.
   136  func IsARMFloatCmp(op obj.As) bool {
   137  	switch op {
   138  	case arm.ACMPF, arm.ACMPD:
   139  		return true
   140  	}
   141  	return false
   142  }
   143  
   144  // ARMMRCOffset implements the peculiar encoding of the MRC and MCR instructions.
   145  // The difference between MRC and MCR is represented by a bit high in the word, not
   146  // in the usual way by the opcode itself. Asm must use AMRC for both instructions, so
   147  // we return the opcode for MRC so that asm doesn't need to import obj/arm.
   148  func ARMMRCOffset(op obj.As, cond string, x0, x1, x2, x3, x4, x5 int64) (offset int64, op0 obj.As, ok bool) {
   149  	op1 := int64(0)
   150  	if op == arm.AMRC {
   151  		op1 = 1
   152  	}
   153  	bits, ok := ParseARMCondition(cond)
   154  	if !ok {
   155  		return
   156  	}
   157  	offset = (0xe << 24) | // opcode
   158  		(op1 << 20) | // MCR/MRC
   159  		((int64(bits) ^ arm.C_SCOND_XOR) << 28) | // scond
   160  		((x0 & 15) << 8) | //coprocessor number
   161  		((x1 & 7) << 21) | // coprocessor operation
   162  		((x2 & 15) << 12) | // ARM register
   163  		((x3 & 15) << 16) | // Crn
   164  		((x4 & 15) << 0) | // Crm
   165  		((x5 & 7) << 5) | // coprocessor information
   166  		(1 << 4) /* must be set */
   167  	return offset, arm.AMRC, true
   168  }
   169  
   170  // IsARMMULA reports whether the op (as defined by an arm.A* constant) is
   171  // MULA, MULS, MMULA, MMULS, MULABB, MULAWB or MULAWT, the 4-operand instructions.
   172  func IsARMMULA(op obj.As) bool {
   173  	switch op {
   174  	case arm.AMULA, arm.AMULS, arm.AMMULA, arm.AMMULS, arm.AMULABB, arm.AMULAWB, arm.AMULAWT:
   175  		return true
   176  	}
   177  	return false
   178  }
   179  
   180  var bcode = []obj.As{
   181  	arm.ABEQ,
   182  	arm.ABNE,
   183  	arm.ABCS,
   184  	arm.ABCC,
   185  	arm.ABMI,
   186  	arm.ABPL,
   187  	arm.ABVS,
   188  	arm.ABVC,
   189  	arm.ABHI,
   190  	arm.ABLS,
   191  	arm.ABGE,
   192  	arm.ABLT,
   193  	arm.ABGT,
   194  	arm.ABLE,
   195  	arm.AB,
   196  	obj.ANOP,
   197  }
   198  
   199  // ARMConditionCodes handles the special condition code situation for the ARM.
   200  // It returns a boolean to indicate success; failure means cond was unrecognized.
   201  func ARMConditionCodes(prog *obj.Prog, cond string) bool {
   202  	if cond == "" {
   203  		return true
   204  	}
   205  	bits, ok := ParseARMCondition(cond)
   206  	if !ok {
   207  		return false
   208  	}
   209  	/* hack to make B.NE etc. work: turn it into the corresponding conditional */
   210  	if prog.As == arm.AB {
   211  		prog.As = bcode[(bits^arm.C_SCOND_XOR)&0xf]
   212  		bits = (bits &^ 0xf) | arm.C_SCOND_NONE
   213  	}
   214  	prog.Scond = bits
   215  	return true
   216  }
   217  
   218  // ParseARMCondition parses the conditions attached to an ARM instruction.
   219  // The input is a single string consisting of period-separated condition
   220  // codes, such as ".P.W". An initial period is ignored.
   221  func ParseARMCondition(cond string) (uint8, bool) {
   222  	return parseARMCondition(cond, armLS, armSCOND)
   223  }
   224  
   225  func parseARMCondition(cond string, ls, scond map[string]uint8) (uint8, bool) {
   226  	cond = strings.TrimPrefix(cond, ".")
   227  	if cond == "" {
   228  		return arm.C_SCOND_NONE, true
   229  	}
   230  	names := strings.Split(cond, ".")
   231  	bits := uint8(0)
   232  	for _, name := range names {
   233  		if b, present := ls[name]; present {
   234  			bits |= b
   235  			continue
   236  		}
   237  		if b, present := scond[name]; present {
   238  			bits = (bits &^ arm.C_SCOND) | b
   239  			continue
   240  		}
   241  		return 0, false
   242  	}
   243  	return bits, true
   244  }
   245  
   246  func armRegisterNumber(name string, n int16) (int16, bool) {
   247  	if n < 0 || 15 < n {
   248  		return 0, false
   249  	}
   250  	switch name {
   251  	case "R":
   252  		return arm.REG_R0 + n, true
   253  	case "F":
   254  		return arm.REG_F0 + n, true
   255  	}
   256  	return 0, false
   257  }
   258
View as plain text