1 /* Table of relaxations for Xtensa assembly. 2 Copyright (C) 2003-2016 Free Software Foundation, Inc. 3 4 This file is part of GAS, the GNU Assembler. 5 6 GAS is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3, or (at your option) 9 any later version. 10 11 GAS is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GAS; see the file COPYING. If not, write to 18 the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 /* This file contains the code for generating runtime data structures 22 for relaxation pattern matching from statically specified strings. 23 Each action contains an instruction pattern to match and 24 preconditions for the match as well as an expansion if the pattern 25 matches. The preconditions can specify that two operands are the 26 same or an operand is a specific constant or register. The expansion 27 uses the bound variables from the pattern to specify that specific 28 operands from the pattern should be used in the result. 29 30 The code determines whether the condition applies to a constant or 31 a register depending on the type of the operand. You may get 32 unexpected results if you don't match the rule against the operand 33 type correctly. 34 35 The patterns match a language like: 36 37 INSN_PATTERN ::= INSN_TEMPL ( '|' PRECOND )* ( '?' OPTIONPRED )* 38 INSN_TEMPL ::= OPCODE ' ' [ OPERAND (',' OPERAND)* ] 39 OPCODE ::= id 40 OPERAND ::= CONSTANT | VARIABLE | SPECIALFN '(' VARIABLE ')' 41 SPECIALFN ::= 'HI24S' | 'F32MINUS' | 'LOW8' 42 | 'HI16' | 'LOW16' 43 VARIABLE ::= '%' id 44 PRECOND ::= OPERAND CMPOP OPERAND 45 CMPOP ::= '==' | '!=' 46 OPTIONPRED ::= OPTIONNAME ('+' OPTIONNAME) 47 OPTIONNAME ::= '"' id '"' 48 49 The replacement language 50 INSN_REPL ::= INSN_LABEL_LIT ( ';' INSN_LABEL_LIT )* 51 INSN_LABEL_LIT ::= INSN_TEMPL 52 | 'LABEL' 53 | 'LITERAL' VARIABLE 54 55 The operands in a PRECOND must be constants or variables bound by 56 the INSN_PATTERN. 57 58 The configuration options define a predicate on the availability of 59 options which must be TRUE for this rule to be valid. Examples are 60 requiring "density" for replacements with density instructions, 61 requiring "const16" for replacements that require const16 62 instructions, etc. The names are interpreted by the assembler to a 63 truth value for a particular frag. 64 65 The operands in the INSN_REPL must be constants, variables bound in 66 the associated INSN_PATTERN, special variables that are bound in 67 the INSN_REPL by LABEL or LITERAL definitions, or special value 68 manipulation functions. 69 70 A simple example of a replacement pattern: 71 {"movi.n %as,%imm", "movi %as,%imm"} would convert the narrow 72 movi.n instruction to the wide movi instruction. 73 74 A more complex example of a branch around: 75 {"beqz %as,%label", "bnez %as,%LABEL;j %label;LABEL"} 76 would convert a branch to a negated branch to the following instruction 77 with a jump to the original label. 78 79 An Xtensa-specific example that generates a literal: 80 {"movi %at,%imm", "LITERAL %imm; l32r %at,%LITERAL"} 81 will convert a movi instruction to an l32r of a literal 82 literal defined in the literal pool. 83 84 Even more complex is a conversion of a load with immediate offset 85 to a load of a freshly generated literal, an explicit add and 86 a load with 0 offset. This transformation is only valid, though 87 when the first and second operands are not the same as specified 88 by the "| %at!=%as" precondition clause. 89 {"l32i %at,%as,%imm | %at!=%as", 90 "LITERAL %imm; l32r %at,%LITERAL; add %at,%at,%as; l32i %at,%at,0"} 91 92 There is special case for loop instructions here, but because we do 93 not currently have the ability to represent the difference of two 94 symbols, the conversion requires special code in the assembler to 95 write the operands of the addi/addmi pair representing the 96 difference of the old and new loop end label. */ 97 98 #include "as.h" 99 #include "xtensa-isa.h" 100 #include "xtensa-relax.h" 101 #include <stddef.h> 102 #include "xtensa-config.h" 103 104 #ifndef XCHAL_HAVE_WIDE_BRANCHES 105 #define XCHAL_HAVE_WIDE_BRANCHES 0 106 #endif 107 108 /* Imported from bfd. */ 109 extern xtensa_isa xtensa_default_isa; 110 111 /* The opname_list is a small list of names that we use for opcode and 112 operand variable names to simplify ownership of these commonly used 113 strings. Strings entered in the table can be compared by pointer 114 equality. */ 115 116 typedef struct opname_list_struct opname_list; 117 typedef opname_list opname_e; 118 119 struct opname_list_struct 120 { 121 char *opname; 122 opname_list *next; 123 }; 124 125 static opname_list *local_opnames = NULL; 126 127 128 /* The "opname_map" and its element structure "opname_map_e" are used 129 for binding an operand number to a name or a constant. */ 130 131 typedef struct opname_map_e_struct opname_map_e; 132 typedef struct opname_map_struct opname_map; 133 134 struct opname_map_e_struct 135 { 136 const char *operand_name; /* If null, then use constant_value. */ 137 int operand_num; 138 unsigned constant_value; 139 opname_map_e *next; 140 }; 141 142 struct opname_map_struct 143 { 144 opname_map_e *head; 145 opname_map_e **tail; 146 }; 147 148 /* The "precond_list" and its element structure "precond_e" represents 149 explicit preconditions comparing operand variables and constants. 150 In the "precond_e" structure, a variable is identified by the name 151 in the "opname" field. If that field is NULL, then the operand 152 is the constant in field "opval". */ 153 154 typedef struct precond_e_struct precond_e; 155 typedef struct precond_list_struct precond_list; 156 157 struct precond_e_struct 158 { 159 const char *opname1; 160 unsigned opval1; 161 CmpOp cmpop; 162 const char *opname2; 163 unsigned opval2; 164 precond_e *next; 165 }; 166 167 struct precond_list_struct 168 { 169 precond_e *head; 170 precond_e **tail; 171 }; 172 173 174 /* The insn_templ represents the INSN_TEMPL instruction template. It 175 is an opcode name with a list of operands. These are used for 176 instruction patterns and replacement patterns. */ 177 178 typedef struct insn_templ_struct insn_templ; 179 struct insn_templ_struct 180 { 181 const char *opcode_name; 182 opname_map operand_map; 183 }; 184 185 186 /* The insn_pattern represents an INSN_PATTERN instruction pattern. 187 It is an instruction template with preconditions that specify when 188 it actually matches a given instruction. */ 189 190 typedef struct insn_pattern_struct insn_pattern; 191 struct insn_pattern_struct 192 { 193 insn_templ t; 194 precond_list preconds; 195 ReqOptionList *options; 196 }; 197 198 199 /* The "insn_repl" and associated element structure "insn_repl_e" 200 instruction replacement list is a list of 201 instructions/LITERALS/LABELS with constant operands or operands 202 with names bound to the operand names in the associated pattern. */ 203 204 typedef struct insn_repl_e_struct insn_repl_e; 205 struct insn_repl_e_struct 206 { 207 insn_templ t; 208 insn_repl_e *next; 209 }; 210 211 typedef struct insn_repl_struct insn_repl; 212 struct insn_repl_struct 213 { 214 insn_repl_e *head; 215 insn_repl_e **tail; 216 }; 217 218 219 /* The split_rec is a vector of allocated char * pointers. */ 220 221 typedef struct split_rec_struct split_rec; 222 struct split_rec_struct 223 { 224 char **vec; 225 int count; 226 }; 227 228 /* The "string_pattern_pair" is a set of pairs containing instruction 229 patterns and replacement strings. */ 230 231 typedef struct string_pattern_pair_struct string_pattern_pair; 232 struct string_pattern_pair_struct 233 { 234 const char *pattern; 235 const char *replacement; 236 }; 237 238 239 /* The widen_spec_list is a list of valid substitutions that generate 241 wider representations. These are generally used to specify 242 replacements for instructions whose immediates do not fit their 243 encodings. A valid transition may require multiple steps of 244 one-to-one instruction replacements with a final multiple 245 instruction replacement. As an example, here are the transitions 246 required to replace an 'addi.n' with an 'addi', 'addmi'. 247 248 addi.n a4, 0x1010 249 => addi a4, 0x1010 250 => addmi a4, 0x1010 251 => addmi a4, 0x1000, addi a4, 0x10. 252 253 See the comments in xg_assembly_relax for some important details 254 regarding how these chains must be built. */ 255 256 static string_pattern_pair widen_spec_list[] = 257 { 258 {"add.n %ar,%as,%at ? IsaUseDensityInstruction", "add %ar,%as,%at"}, 259 {"addi.n %ar,%as,%imm ? IsaUseDensityInstruction", "addi %ar,%as,%imm"}, 260 {"beqz.n %as,%label ? IsaUseDensityInstruction", "beqz %as,%label"}, 261 {"bnez.n %as,%label ? IsaUseDensityInstruction", "bnez %as,%label"}, 262 {"l32i.n %at,%as,%imm ? IsaUseDensityInstruction", "l32i %at,%as,%imm"}, 263 {"mov.n %at,%as ? IsaUseDensityInstruction", "or %at,%as,%as"}, 264 {"movi.n %as,%imm ? IsaUseDensityInstruction", "movi %as,%imm"}, 265 {"nop.n ? IsaUseDensityInstruction ? realnop", "nop"}, 266 {"nop.n ? IsaUseDensityInstruction ? no-realnop", "or 1,1,1"}, 267 {"ret.n %as ? IsaUseDensityInstruction", "ret %as"}, 268 {"retw.n %as ? IsaUseDensityInstruction", "retw %as"}, 269 {"s32i.n %at,%as,%imm ? IsaUseDensityInstruction", "s32i %at,%as,%imm"}, 270 {"srli %at,%as,%imm", "extui %at,%as,%imm,F32MINUS(%imm)"}, 271 {"slli %ar,%as,0", "or %ar,%as,%as"}, 272 273 /* Widening with literals or const16. */ 274 {"movi %at,%imm ? IsaUseL32R ", 275 "LITERAL %imm; l32r %at,%LITERAL"}, 276 {"movi %at,%imm ? IsaUseConst16", 277 "const16 %at,HI16U(%imm); const16 %at,LOW16U(%imm)"}, 278 279 {"addi %ar,%as,%imm", "addmi %ar,%as,%imm"}, 280 /* LOW8 is the low 8 bits of the Immed 281 MID8S is the middle 8 bits of the Immed */ 282 {"addmi %ar,%as,%imm", "addmi %ar,%as,HI24S(%imm); addi %ar,%ar,LOW8(%imm)"}, 283 284 /* In the end convert to either an l32r or const16. */ 285 {"addmi %ar,%as,%imm | %ar!=%as ? IsaUseL32R", 286 "LITERAL %imm; l32r %ar,%LITERAL; add %ar,%as,%ar"}, 287 {"addmi %ar,%as,%imm | %ar!=%as ? IsaUseConst16", 288 "const16 %ar,HI16U(%imm); const16 %ar,LOW16U(%imm); add %ar,%as,%ar"}, 289 290 /* Widening the load instructions with too-large immediates */ 291 {"l8ui %at,%as,%imm | %at!=%as ? IsaUseL32R", 292 "LITERAL %imm; l32r %at,%LITERAL; add %at,%at,%as; l8ui %at,%at,0"}, 293 {"l16si %at,%as,%imm | %at!=%as ? IsaUseL32R", 294 "LITERAL %imm; l32r %at,%LITERAL; add %at,%at,%as; l16si %at,%at,0"}, 295 {"l16ui %at,%as,%imm | %at!=%as ? IsaUseL32R", 296 "LITERAL %imm; l32r %at,%LITERAL; add %at,%at,%as; l16ui %at,%at,0"}, 297 {"l32i %at,%as,%imm | %at!=%as ? IsaUseL32R", 298 "LITERAL %imm; l32r %at,%LITERAL; add %at,%at,%as; l32i %at,%at,0"}, 299 300 /* Widening load instructions with const16s. */ 301 {"l8ui %at,%as,%imm | %at!=%as ? IsaUseConst16", 302 "const16 %at,HI16U(%imm); const16 %at,LOW16U(%imm); add %at,%at,%as; l8ui %at,%at,0"}, 303 {"l16si %at,%as,%imm | %at!=%as ? IsaUseConst16", 304 "const16 %at,HI16U(%imm); const16 %at,LOW16U(%imm); add %at,%at,%as; l16si %at,%at,0"}, 305 {"l16ui %at,%as,%imm | %at!=%as ? IsaUseConst16", 306 "const16 %at,HI16U(%imm); const16 %at,LOW16U(%imm); add %at,%at,%as; l16ui %at,%at,0"}, 307 {"l32i %at,%as,%imm | %at!=%as ? IsaUseConst16", 308 "const16 %at,HI16U(%imm); const16 %at,LOW16U(%imm); add %at,%at,%as; l32i %at,%at,0"}, 309 310 /* This is only PART of the loop instruction. In addition, 311 hardcoded into its use is a modification of the final operand in 312 the instruction in bytes 9 and 12. */ 313 {"loop %as,%label | %as!=1 ? IsaUseLoops", 314 "loop %as,%LABEL;" 315 "rsr.lend %as;" /* LEND */ 316 "wsr.lbeg %as;" /* LBEG */ 317 "addi %as, %as, 0;" /* lo8(%label-%LABEL1) */ 318 "addmi %as, %as, 0;" /* mid8(%label-%LABEL1) */ 319 "wsr.lend %as;" 320 "isync;" 321 "rsr.lcount %as;" /* LCOUNT */ 322 "addi %as, %as, 1;" /* density -> addi.n %as, %as, 1 */ 323 "LABEL"}, 324 {"loopgtz %as,%label | %as!=1 ? IsaUseLoops", 325 "beqz %as,%label;" 326 "bltz %as,%label;" 327 "loopgtz %as,%LABEL;" 328 "rsr.lend %as;" /* LEND */ 329 "wsr.lbeg %as;" /* LBEG */ 330 "addi %as, %as, 0;" /* lo8(%label-%LABEL1) */ 331 "addmi %as, %as, 0;" /* mid8(%label-%LABEL1) */ 332 "wsr.lend %as;" 333 "isync;" 334 "rsr.lcount %as;" /* LCOUNT */ 335 "addi %as, %as, 1;" /* density -> addi.n %as, %as, 1 */ 336 "LABEL"}, 337 {"loopnez %as,%label | %as!=1 ? IsaUseLoops", 338 "beqz %as,%label;" 339 "loopnez %as,%LABEL;" 340 "rsr.lend %as;" /* LEND */ 341 "wsr.lbeg %as;" /* LBEG */ 342 "addi %as, %as, 0;" /* lo8(%label-%LABEL1) */ 343 "addmi %as, %as, 0;" /* mid8(%label-%LABEL1) */ 344 "wsr.lend %as;" 345 "isync;" 346 "rsr.lcount %as;" /* LCOUNT */ 347 "addi %as, %as, 1;" /* density -> addi.n %as, %as, 1 */ 348 "LABEL"}, 349 350 /* Relaxing to wide branches. Order is important here. With wide 351 branches, there is more than one correct relaxation for an 352 out-of-range branch. Put the wide branch relaxations first in the 353 table since they are more efficient than the branch-around 354 relaxations. */ 355 356 {"beqz %as,%label ? IsaUseWideBranches", "WIDE.beqz %as,%label"}, 357 {"bnez %as,%label ? IsaUseWideBranches", "WIDE.bnez %as,%label"}, 358 {"bgez %as,%label ? IsaUseWideBranches", "WIDE.bgez %as,%label"}, 359 {"bltz %as,%label ? IsaUseWideBranches", "WIDE.bltz %as,%label"}, 360 {"beqi %as,%imm,%label ? IsaUseWideBranches", "WIDE.beqi %as,%imm,%label"}, 361 {"bnei %as,%imm,%label ? IsaUseWideBranches", "WIDE.bnei %as,%imm,%label"}, 362 {"bgei %as,%imm,%label ? IsaUseWideBranches", "WIDE.bgei %as,%imm,%label"}, 363 {"blti %as,%imm,%label ? IsaUseWideBranches", "WIDE.blti %as,%imm,%label"}, 364 {"bgeui %as,%imm,%label ? IsaUseWideBranches", "WIDE.bgeui %as,%imm,%label"}, 365 {"bltui %as,%imm,%label ? IsaUseWideBranches", "WIDE.bltui %as,%imm,%label"}, 366 {"bbci %as,%imm,%label ? IsaUseWideBranches", "WIDE.bbci %as,%imm,%label"}, 367 {"bbsi %as,%imm,%label ? IsaUseWideBranches", "WIDE.bbsi %as,%imm,%label"}, 368 {"beq %as,%at,%label ? IsaUseWideBranches", "WIDE.beq %as,%at,%label"}, 369 {"bne %as,%at,%label ? IsaUseWideBranches", "WIDE.bne %as,%at,%label"}, 370 {"bge %as,%at,%label ? IsaUseWideBranches", "WIDE.bge %as,%at,%label"}, 371 {"blt %as,%at,%label ? IsaUseWideBranches", "WIDE.blt %as,%at,%label"}, 372 {"bgeu %as,%at,%label ? IsaUseWideBranches", "WIDE.bgeu %as,%at,%label"}, 373 {"bltu %as,%at,%label ? IsaUseWideBranches", "WIDE.bltu %as,%at,%label"}, 374 {"bany %as,%at,%label ? IsaUseWideBranches", "WIDE.bany %as,%at,%label"}, 375 {"bnone %as,%at,%label ? IsaUseWideBranches", "WIDE.bnone %as,%at,%label"}, 376 {"ball %as,%at,%label ? IsaUseWideBranches", "WIDE.ball %as,%at,%label"}, 377 {"bnall %as,%at,%label ? IsaUseWideBranches", "WIDE.bnall %as,%at,%label"}, 378 {"bbc %as,%at,%label ? IsaUseWideBranches", "WIDE.bbc %as,%at,%label"}, 379 {"bbs %as,%at,%label ? IsaUseWideBranches", "WIDE.bbs %as,%at,%label"}, 380 381 /* Widening branch comparisons eq/ne to zero. Prefer relaxing to narrow 382 branches if the density option is available. */ 383 {"beqz %as,%label ? IsaUseDensityInstruction", "bnez.n %as,%LABEL;j %label;LABEL"}, 384 {"bnez %as,%label ? IsaUseDensityInstruction", "beqz.n %as,%LABEL;j %label;LABEL"}, 385 {"beqz %as,%label", "bnez %as,%LABEL;j %label;LABEL"}, 386 {"bnez %as,%label", "beqz %as,%LABEL;j %label;LABEL"}, 387 {"WIDE.beqz %as,%label ? IsaUseDensityInstruction", "bnez.n %as,%LABEL;j %label;LABEL"}, 388 {"WIDE.bnez %as,%label ? IsaUseDensityInstruction", "beqz.n %as,%LABEL;j %label;LABEL"}, 389 {"WIDE.beqz %as,%label", "bnez %as,%LABEL;j %label;LABEL"}, 390 {"WIDE.bnez %as,%label", "beqz %as,%LABEL;j %label;LABEL"}, 391 392 /* Widening expect-taken branches. */ 393 {"beqzt %as,%label ? IsaUsePredictedBranches", "bnez %as,%LABEL;j %label;LABEL"}, 394 {"bnezt %as,%label ? IsaUsePredictedBranches", "beqz %as,%LABEL;j %label;LABEL"}, 395 {"beqt %as,%at,%label ? IsaUsePredictedBranches", "bne %as,%at,%LABEL;j %label;LABEL"}, 396 {"bnet %as,%at,%label ? IsaUsePredictedBranches", "beq %as,%at,%LABEL;j %label;LABEL"}, 397 398 /* Widening branches from the Xtensa boolean option. */ 399 {"bt %bs,%label ? IsaUseBooleans", "bf %bs,%LABEL;j %label;LABEL"}, 400 {"bf %bs,%label ? IsaUseBooleans", "bt %bs,%LABEL;j %label;LABEL"}, 401 402 /* Other branch-around-jump widenings. */ 403 {"bgez %as,%label", "bltz %as,%LABEL;j %label;LABEL"}, 404 {"bltz %as,%label", "bgez %as,%LABEL;j %label;LABEL"}, 405 {"beqi %as,%imm,%label", "bnei %as,%imm,%LABEL;j %label;LABEL"}, 406 {"bnei %as,%imm,%label", "beqi %as,%imm,%LABEL;j %label;LABEL"}, 407 {"bgei %as,%imm,%label", "blti %as,%imm,%LABEL;j %label;LABEL"}, 408 {"blti %as,%imm,%label", "bgei %as,%imm,%LABEL;j %label;LABEL"}, 409 {"bgeui %as,%imm,%label", "bltui %as,%imm,%LABEL;j %label;LABEL"}, 410 {"bltui %as,%imm,%label", "bgeui %as,%imm,%LABEL;j %label;LABEL"}, 411 {"bbci %as,%imm,%label", "bbsi %as,%imm,%LABEL;j %label;LABEL"}, 412 {"bbsi %as,%imm,%label", "bbci %as,%imm,%LABEL;j %label;LABEL"}, 413 {"beq %as,%at,%label", "bne %as,%at,%LABEL;j %label;LABEL"}, 414 {"bne %as,%at,%label", "beq %as,%at,%LABEL;j %label;LABEL"}, 415 {"bge %as,%at,%label", "blt %as,%at,%LABEL;j %label;LABEL"}, 416 {"blt %as,%at,%label", "bge %as,%at,%LABEL;j %label;LABEL"}, 417 {"bgeu %as,%at,%label", "bltu %as,%at,%LABEL;j %label;LABEL"}, 418 {"bltu %as,%at,%label", "bgeu %as,%at,%LABEL;j %label;LABEL"}, 419 {"bany %as,%at,%label", "bnone %as,%at,%LABEL;j %label;LABEL"}, 420 {"bnone %as,%at,%label", "bany %as,%at,%LABEL;j %label;LABEL"}, 421 {"ball %as,%at,%label", "bnall %as,%at,%LABEL;j %label;LABEL"}, 422 {"bnall %as,%at,%label", "ball %as,%at,%LABEL;j %label;LABEL"}, 423 {"bbc %as,%at,%label", "bbs %as,%at,%LABEL;j %label;LABEL"}, 424 {"bbs %as,%at,%label", "bbc %as,%at,%LABEL;j %label;LABEL"}, 425 426 {"WIDE.bgez %as,%label", "bltz %as,%LABEL;j %label;LABEL"}, 427 {"WIDE.bltz %as,%label", "bgez %as,%LABEL;j %label;LABEL"}, 428 {"WIDE.beqi %as,%imm,%label", "bnei %as,%imm,%LABEL;j %label;LABEL"}, 429 {"WIDE.bnei %as,%imm,%label", "beqi %as,%imm,%LABEL;j %label;LABEL"}, 430 {"WIDE.bgei %as,%imm,%label", "blti %as,%imm,%LABEL;j %label;LABEL"}, 431 {"WIDE.blti %as,%imm,%label", "bgei %as,%imm,%LABEL;j %label;LABEL"}, 432 {"WIDE.bgeui %as,%imm,%label", "bltui %as,%imm,%LABEL;j %label;LABEL"}, 433 {"WIDE.bltui %as,%imm,%label", "bgeui %as,%imm,%LABEL;j %label;LABEL"}, 434 {"WIDE.bbci %as,%imm,%label", "bbsi %as,%imm,%LABEL;j %label;LABEL"}, 435 {"WIDE.bbsi %as,%imm,%label", "bbci %as,%imm,%LABEL;j %label;LABEL"}, 436 {"WIDE.beq %as,%at,%label", "bne %as,%at,%LABEL;j %label;LABEL"}, 437 {"WIDE.bne %as,%at,%label", "beq %as,%at,%LABEL;j %label;LABEL"}, 438 {"WIDE.bge %as,%at,%label", "blt %as,%at,%LABEL;j %label;LABEL"}, 439 {"WIDE.blt %as,%at,%label", "bge %as,%at,%LABEL;j %label;LABEL"}, 440 {"WIDE.bgeu %as,%at,%label", "bltu %as,%at,%LABEL;j %label;LABEL"}, 441 {"WIDE.bltu %as,%at,%label", "bgeu %as,%at,%LABEL;j %label;LABEL"}, 442 {"WIDE.bany %as,%at,%label", "bnone %as,%at,%LABEL;j %label;LABEL"}, 443 {"WIDE.bnone %as,%at,%label", "bany %as,%at,%LABEL;j %label;LABEL"}, 444 {"WIDE.ball %as,%at,%label", "bnall %as,%at,%LABEL;j %label;LABEL"}, 445 {"WIDE.bnall %as,%at,%label", "ball %as,%at,%LABEL;j %label;LABEL"}, 446 {"WIDE.bbc %as,%at,%label", "bbs %as,%at,%LABEL;j %label;LABEL"}, 447 {"WIDE.bbs %as,%at,%label", "bbc %as,%at,%LABEL;j %label;LABEL"}, 448 449 /* Expanding calls with literals. */ 450 {"call0 %label,%ar0 ? IsaUseL32R", 451 "LITERAL %label; l32r a0,%LITERAL; callx0 a0,%ar0"}, 452 {"call4 %label,%ar4 ? IsaUseL32R", 453 "LITERAL %label; l32r a4,%LITERAL; callx4 a4,%ar4"}, 454 {"call8 %label,%ar8 ? IsaUseL32R", 455 "LITERAL %label; l32r a8,%LITERAL; callx8 a8,%ar8"}, 456 {"call12 %label,%ar12 ? IsaUseL32R", 457 "LITERAL %label; l32r a12,%LITERAL; callx12 a12,%ar12"}, 458 459 /* Expanding calls with const16. */ 460 {"call0 %label,%ar0 ? IsaUseConst16", 461 "const16 a0,HI16U(%label); const16 a0,LOW16U(%label); callx0 a0,%ar0"}, 462 {"call4 %label,%ar4 ? IsaUseConst16", 463 "const16 a4,HI16U(%label); const16 a4,LOW16U(%label); callx4 a4,%ar4"}, 464 {"call8 %label,%ar8 ? IsaUseConst16", 465 "const16 a8,HI16U(%label); const16 a8,LOW16U(%label); callx8 a8,%ar8"}, 466 {"call12 %label,%ar12 ? IsaUseConst16", 467 "const16 a12,HI16U(%label); const16 a12,LOW16U(%label); callx12 a12,%ar12"}, 468 469 /* Expanding j.l with literals. */ 470 {"j %label ? FREEREG ? IsaUseL32R", 471 "LITERAL %label; l32r FREEREG,%LITERAL; jx FREEREG"}, 472 /* Expanding j.l with const16. */ 473 {"j %label ? FREEREG ? IsaUseConst16", 474 "const16 FREEREG,HI16U(%label); const16 FREEREG,LOW16U(%label); jx FREEREG"}, 475 }; 476 477 #define WIDEN_COUNT (sizeof (widen_spec_list) / sizeof (string_pattern_pair)) 478 479 480 /* The simplify_spec_list specifies simplifying transformations that 481 will reduce the instruction width or otherwise simplify an 482 instruction. These are usually applied before relaxation in the 483 assembler. It is always legal to simplify. Even for "addi as, 0", 484 the "addi.n as, 0" will eventually be widened back to an "addi 0" 485 after the widening table is applied. Note: The usage of this table 486 has changed somewhat so that it is entirely specific to "narrowing" 487 instructions to use the density option. This table is not used at 488 all when the density option is not available. */ 489 490 string_pattern_pair simplify_spec_list[] = 491 { 492 {"add %ar,%as,%at ? IsaUseDensityInstruction", "add.n %ar,%as,%at"}, 493 {"addi.n %ar,%as,0 ? IsaUseDensityInstruction", "mov.n %ar,%as"}, 494 {"addi %ar,%as,0 ? IsaUseDensityInstruction", "mov.n %ar,%as"}, 495 {"addi %ar,%as,%imm ? IsaUseDensityInstruction", "addi.n %ar,%as,%imm"}, 496 {"addmi %ar,%as,%imm ? IsaUseDensityInstruction", "addi.n %ar,%as,%imm"}, 497 {"beqz %as,%label ? IsaUseDensityInstruction", "beqz.n %as,%label"}, 498 {"bnez %as,%label ? IsaUseDensityInstruction", "bnez.n %as,%label"}, 499 {"l32i %at,%as,%imm ? IsaUseDensityInstruction", "l32i.n %at,%as,%imm"}, 500 {"movi %as,%imm ? IsaUseDensityInstruction", "movi.n %as,%imm"}, 501 {"nop ? realnop ? IsaUseDensityInstruction", "nop.n"}, 502 {"or %ar,%as,%at | %ar==%as | %as==%at ? IsaUseDensityInstruction", "nop.n"}, 503 {"or %ar,%as,%at | %ar!=%as | %as==%at ? IsaUseDensityInstruction", "mov.n %ar,%as"}, 504 {"ret %as ? IsaUseDensityInstruction", "ret.n %as"}, 505 {"retw %as ? IsaUseDensityInstruction", "retw.n %as"}, 506 {"s32i %at,%as,%imm ? IsaUseDensityInstruction", "s32i.n %at,%as,%imm"}, 507 {"slli %ar,%as,0 ? IsaUseDensityInstruction", "mov.n %ar,%as"} 508 }; 509 510 #define SIMPLIFY_COUNT \ 511 (sizeof (simplify_spec_list) / sizeof (string_pattern_pair)) 512 513 514 /* Externally visible functions. */ 516 517 extern bfd_boolean xg_has_userdef_op_fn (OpType); 518 extern long xg_apply_userdef_op_fn (OpType, long); 519 520 521 static void 522 append_transition (TransitionTable *tt, 523 xtensa_opcode opcode, 524 TransitionRule *t, 525 transition_cmp_fn cmp) 526 { 527 TransitionList *tl = XNEW (TransitionList); 528 TransitionList *prev; 529 TransitionList **t_p; 530 gas_assert (tt != NULL); 531 gas_assert (opcode < tt->num_opcodes); 532 533 prev = tt->table[opcode]; 534 tl->rule = t; 535 tl->next = NULL; 536 if (prev == NULL) 537 { 538 tt->table[opcode] = tl; 539 return; 540 } 541 542 for (t_p = &tt->table[opcode]; (*t_p) != NULL; t_p = &(*t_p)->next) 543 { 544 if (cmp && cmp (t, (*t_p)->rule) < 0) 545 { 546 /* Insert it here. */ 547 tl->next = *t_p; 548 *t_p = tl; 549 return; 550 } 551 } 552 (*t_p) = tl; 553 } 554 555 556 static void 557 append_condition (TransitionRule *tr, Precondition *cond) 558 { 559 PreconditionList *pl = XNEW (PreconditionList); 560 PreconditionList *prev = tr->conditions; 561 PreconditionList *nxt; 562 563 pl->precond = cond; 564 pl->next = NULL; 565 if (prev == NULL) 566 { 567 tr->conditions = pl; 568 return; 569 } 570 nxt = prev->next; 571 while (nxt != NULL) 572 { 573 prev = nxt; 574 nxt = nxt->next; 575 } 576 prev->next = pl; 577 } 578 579 580 static void 581 append_value_condition (TransitionRule *tr, 582 CmpOp cmp, 583 unsigned op1, 584 unsigned op2) 585 { 586 Precondition *cond = XNEW (Precondition); 587 588 cond->cmp = cmp; 589 cond->op_num = op1; 590 cond->typ = OP_OPERAND; 591 cond->op_data = op2; 592 append_condition (tr, cond); 593 } 594 595 596 static void 597 append_constant_value_condition (TransitionRule *tr, 598 CmpOp cmp, 599 unsigned op1, 600 unsigned cnst) 601 { 602 Precondition *cond = XNEW (Precondition); 603 604 cond->cmp = cmp; 605 cond->op_num = op1; 606 cond->typ = OP_CONSTANT; 607 cond->op_data = cnst; 608 append_condition (tr, cond); 609 } 610 611 612 static void 613 append_build_insn (TransitionRule *tr, BuildInstr *bi) 614 { 615 BuildInstr *prev = tr->to_instr; 616 BuildInstr *nxt; 617 618 bi->next = NULL; 619 if (prev == NULL) 620 { 621 tr->to_instr = bi; 622 return; 623 } 624 nxt = prev->next; 625 while (nxt != 0) 626 { 627 prev = nxt; 628 nxt = prev->next; 629 } 630 prev->next = bi; 631 } 632 633 634 static void 635 append_op (BuildInstr *bi, BuildOp *b_op) 636 { 637 BuildOp *prev = bi->ops; 638 BuildOp *nxt; 639 640 if (prev == NULL) 641 { 642 bi->ops = b_op; 643 return; 644 } 645 nxt = prev->next; 646 while (nxt != NULL) 647 { 648 prev = nxt; 649 nxt = nxt->next; 650 } 651 prev->next = b_op; 652 } 653 654 655 static void 656 append_literal_op (BuildInstr *bi, unsigned op1, unsigned src_op) 657 { 658 BuildOp *b_op = XNEW (BuildOp); 659 660 b_op->op_num = op1; 661 b_op->typ = OP_LITERAL; 662 b_op->op_data = src_op; 663 b_op->next = NULL; 664 append_op (bi, b_op); 665 } 666 667 668 static void 669 append_label_op (BuildInstr *bi, unsigned op1) 670 { 671 BuildOp *b_op = XNEW (BuildOp); 672 673 b_op->op_num = op1; 674 b_op->typ = OP_LABEL; 675 b_op->op_data = 0; 676 b_op->next = NULL; 677 append_op (bi, b_op); 678 } 679 680 681 static void 682 append_constant_op (BuildInstr *bi, unsigned op1, unsigned cnst) 683 { 684 BuildOp *b_op = XNEW (BuildOp); 685 686 b_op->op_num = op1; 687 b_op->typ = OP_CONSTANT; 688 b_op->op_data = cnst; 689 b_op->next = NULL; 690 append_op (bi, b_op); 691 } 692 693 694 static void 695 append_field_op (BuildInstr *bi, unsigned op1, unsigned src_op) 696 { 697 BuildOp *b_op = XNEW (BuildOp); 698 699 b_op->op_num = op1; 700 b_op->typ = OP_OPERAND; 701 b_op->op_data = src_op; 702 b_op->next = NULL; 703 append_op (bi, b_op); 704 } 705 706 707 /* These could be generated but are not currently. */ 708 709 static void 710 append_user_fn_field_op (BuildInstr *bi, 711 unsigned op1, 712 OpType typ, 713 unsigned src_op) 714 { 715 BuildOp *b_op = XNEW (BuildOp); 716 717 b_op->op_num = op1; 718 b_op->typ = typ; 719 b_op->op_data = src_op; 720 b_op->next = NULL; 721 append_op (bi, b_op); 722 } 723 724 725 /* These operand functions are the semantics of user-defined 726 operand functions. */ 727 728 static long 729 operand_function_HI24S (long a) 730 { 731 if (a & 0x80) 732 return (a & (~0xff)) + 0x100; 733 else 734 return (a & (~0xff)); 735 } 736 737 738 static long 739 operand_function_F32MINUS (long a) 740 { 741 return (32 - a); 742 } 743 744 745 static long 746 operand_function_LOW8 (long a) 747 { 748 if (a & 0x80) 749 return (a & 0xff) | ~0xff; 750 else 751 return (a & 0xff); 752 } 753 754 755 static long 756 operand_function_LOW16U (long a) 757 { 758 return (a & 0xffff); 759 } 760 761 762 static long 763 operand_function_HI16U (long a) 764 { 765 unsigned long b = a & 0xffff0000; 766 return (long) (b >> 16); 767 } 768 769 770 bfd_boolean 771 xg_has_userdef_op_fn (OpType op) 772 { 773 switch (op) 774 { 775 case OP_OPERAND_F32MINUS: 776 case OP_OPERAND_LOW8: 777 case OP_OPERAND_HI24S: 778 case OP_OPERAND_LOW16U: 779 case OP_OPERAND_HI16U: 780 return TRUE; 781 default: 782 break; 783 } 784 return FALSE; 785 } 786 787 788 long 789 xg_apply_userdef_op_fn (OpType op, long a) 790 { 791 switch (op) 792 { 793 case OP_OPERAND_F32MINUS: 794 return operand_function_F32MINUS (a); 795 case OP_OPERAND_LOW8: 796 return operand_function_LOW8 (a); 797 case OP_OPERAND_HI24S: 798 return operand_function_HI24S (a); 799 case OP_OPERAND_LOW16U: 800 return operand_function_LOW16U (a); 801 case OP_OPERAND_HI16U: 802 return operand_function_HI16U (a); 803 default: 804 break; 805 } 806 return FALSE; 807 } 808 809 810 /* Generate a transition table. */ 811 812 static const char * 813 enter_opname_n (const char *name, int len) 814 { 815 opname_e *op; 816 817 for (op = local_opnames; op != NULL; op = op->next) 818 { 819 if (strlen (op->opname) == (unsigned) len 820 && strncmp (op->opname, name, len) == 0) 821 return op->opname; 822 } 823 op = XNEW (opname_e); 824 op->opname = xmemdup0 (name, len); 825 return op->opname; 826 } 827 828 829 static const char * 830 enter_opname (const char *name) 831 { 832 opname_e *op; 833 834 for (op = local_opnames; op != NULL; op = op->next) 835 { 836 if (strcmp (op->opname, name) == 0) 837 return op->opname; 838 } 839 op = XNEW (opname_e); 840 op->opname = xstrdup (name); 841 return op->opname; 842 } 843 844 845 static void 846 init_opname_map (opname_map *m) 847 { 848 m->head = NULL; 849 m->tail = &m->head; 850 } 851 852 853 static void 854 clear_opname_map (opname_map *m) 855 { 856 opname_map_e *e; 857 858 while (m->head != NULL) 859 { 860 e = m->head; 861 m->head = e->next; 862 free (e); 863 } 864 m->tail = &m->head; 865 } 866 867 868 static bfd_boolean 869 same_operand_name (const opname_map_e *m1, const opname_map_e *m2) 870 { 871 if (m1->operand_name == NULL || m2->operand_name == NULL) 872 return FALSE; 873 return (m1->operand_name == m2->operand_name); 874 } 875 876 877 static opname_map_e * 878 get_opmatch (opname_map *map, const char *operand_name) 879 { 880 opname_map_e *m; 881 882 for (m = map->head; m != NULL; m = m->next) 883 { 884 if (strcmp (m->operand_name, operand_name) == 0) 885 return m; 886 } 887 return NULL; 888 } 889 890 891 static bfd_boolean 892 op_is_constant (const opname_map_e *m1) 893 { 894 return (m1->operand_name == NULL); 895 } 896 897 898 static unsigned 899 op_get_constant (const opname_map_e *m1) 900 { 901 gas_assert (m1->operand_name == NULL); 902 return m1->constant_value; 903 } 904 905 906 static void 907 init_precond_list (precond_list *l) 908 { 909 l->head = NULL; 910 l->tail = &l->head; 911 } 912 913 914 static void 915 clear_precond_list (precond_list *l) 916 { 917 precond_e *e; 918 919 while (l->head != NULL) 920 { 921 e = l->head; 922 l->head = e->next; 923 free (e); 924 } 925 l->tail = &l->head; 926 } 927 928 929 static void 930 init_insn_templ (insn_templ *t) 931 { 932 t->opcode_name = NULL; 933 init_opname_map (&t->operand_map); 934 } 935 936 937 static void 938 clear_insn_templ (insn_templ *t) 939 { 940 clear_opname_map (&t->operand_map); 941 } 942 943 944 static void 945 init_insn_pattern (insn_pattern *p) 946 { 947 init_insn_templ (&p->t); 948 init_precond_list (&p->preconds); 949 p->options = NULL; 950 } 951 952 953 static void 954 clear_insn_pattern (insn_pattern *p) 955 { 956 clear_insn_templ (&p->t); 957 clear_precond_list (&p->preconds); 958 } 959 960 961 static void 962 init_insn_repl (insn_repl *r) 963 { 964 r->head = NULL; 965 r->tail = &r->head; 966 } 967 968 969 static void 970 clear_insn_repl (insn_repl *r) 971 { 972 insn_repl_e *e; 973 974 while (r->head != NULL) 975 { 976 e = r->head; 977 r->head = e->next; 978 clear_insn_templ (&e->t); 979 } 980 r->tail = &r->head; 981 } 982 983 984 static int 985 insn_templ_operand_count (const insn_templ *t) 986 { 987 int i = 0; 988 const opname_map_e *op; 989 990 for (op = t->operand_map.head; op != NULL; op = op->next, i++) 991 ; 992 return i; 993 } 994 995 996 /* Convert a string to a number. E.G.: parse_constant("10", &num) */ 997 998 static bfd_boolean 999 parse_constant (const char *in, unsigned *val_p) 1000 { 1001 unsigned val = 0; 1002 const char *p; 1003 1004 if (in == NULL) 1005 return FALSE; 1006 p = in; 1007 1008 while (*p != '\0') 1009 { 1010 if (*p >= '0' && *p <= '9') 1011 val = val * 10 + (*p - '0'); 1012 else 1013 return FALSE; 1014 ++p; 1015 } 1016 *val_p = val; 1017 return TRUE; 1018 } 1019 1020 1021 static bfd_boolean 1022 parse_special_fn (const char *name, 1023 const char **fn_name_p, 1024 const char **arg_name_p) 1025 { 1026 const char *p_start; 1027 const char *p_end; 1028 1029 p_start = strchr (name, '('); 1030 if (p_start == NULL) 1031 return FALSE; 1032 1033 p_end = strchr (p_start, ')'); 1034 1035 if (p_end == NULL) 1036 return FALSE; 1037 1038 if (p_end[1] != '\0') 1039 return FALSE; 1040 1041 *fn_name_p = enter_opname_n (name, p_start - name); 1042 *arg_name_p = enter_opname_n (p_start + 1, p_end - p_start - 1); 1043 return TRUE; 1044 } 1045 1046 1047 static const char * 1048 skip_white (const char *p) 1049 { 1050 if (p == NULL) 1051 return p; 1052 while (*p == ' ') 1053 ++p; 1054 return p; 1055 } 1056 1057 1058 static void 1059 trim_whitespace (char *in) 1060 { 1061 char *last_white = NULL; 1062 char *p = in; 1063 1064 while (p && *p != '\0') 1065 { 1066 while (*p == ' ') 1067 { 1068 if (last_white == NULL) 1069 last_white = p; 1070 p++; 1071 } 1072 if (*p != '\0') 1073 { 1074 last_white = NULL; 1075 p++; 1076 } 1077 } 1078 if (last_white) 1079 *last_white = '\0'; 1080 } 1081 1082 1083 /* Split a string into component strings where "c" is the 1084 delimiter. Place the result in the split_rec. */ 1085 1086 static void 1087 split_string (split_rec *rec, 1088 const char *in, 1089 char c, 1090 bfd_boolean elide_whitespace) 1091 { 1092 int cnt = 0; 1093 int i; 1094 const char *p = in; 1095 1096 while (p != NULL && *p != '\0') 1097 { 1098 cnt++; 1099 p = strchr (p, c); 1100 if (p) 1101 p++; 1102 } 1103 rec->count = cnt; 1104 rec->vec = NULL; 1105 1106 if (rec->count == 0) 1107 return; 1108 1109 rec->vec = XNEWVEC (char *, cnt); 1110 for (i = 0; i < cnt; i++) 1111 rec->vec[i] = 0; 1112 1113 p = in; 1114 for (i = 0; i < cnt; i++) 1115 { 1116 const char *q; 1117 int len; 1118 1119 q = p; 1120 if (elide_whitespace) 1121 q = skip_white (q); 1122 1123 p = strchr (q, c); 1124 if (p == NULL) 1125 rec->vec[i] = xstrdup (q); 1126 else 1127 { 1128 len = p - q; 1129 rec->vec[i] = xmemdup0 (q, len); 1130 p++; 1131 } 1132 1133 if (elide_whitespace) 1134 trim_whitespace (rec->vec[i]); 1135 } 1136 } 1137 1138 1139 static void 1140 clear_split_rec (split_rec *rec) 1141 { 1142 int i; 1143 1144 for (i = 0; i < rec->count; i++) 1145 free (rec->vec[i]); 1146 1147 if (rec->count > 0) 1148 free (rec->vec); 1149 } 1150 1151 1152 /* Initialize a split record. The split record must be initialized 1153 before split_string is called. */ 1154 1155 static void 1156 init_split_rec (split_rec *rec) 1157 { 1158 rec->vec = NULL; 1159 rec->count = 0; 1160 } 1161 1162 1163 /* Parse an instruction template like "insn op1, op2, op3". */ 1164 1165 static bfd_boolean 1166 parse_insn_templ (const char *s, insn_templ *t) 1167 { 1168 const char *p = s; 1169 int insn_name_len; 1170 split_rec oprec; 1171 int i; 1172 1173 /* First find the first whitespace. */ 1174 1175 init_split_rec (&oprec); 1176 1177 p = skip_white (p); 1178 insn_name_len = strcspn (s, " "); 1179 if (insn_name_len == 0) 1180 return FALSE; 1181 1182 init_insn_templ (t); 1183 t->opcode_name = enter_opname_n (p, insn_name_len); 1184 1185 p = p + insn_name_len; 1186 1187 /* Split by ',' and skip beginning and trailing whitespace. */ 1188 split_string (&oprec, p, ',', TRUE); 1189 1190 for (i = 0; i < oprec.count; i++) 1191 { 1192 const char *opname = oprec.vec[i]; 1193 opname_map_e *e = XNEW (opname_map_e); 1194 e->next = NULL; 1195 e->operand_name = NULL; 1196 e->constant_value = 0; 1197 e->operand_num = i; 1198 1199 /* If it begins with a number, assume that it is a number. */ 1200 if (opname && opname[0] >= '0' && opname[0] <= '9') 1201 { 1202 unsigned val; 1203 1204 if (parse_constant (opname, &val)) 1205 e->constant_value = val; 1206 else 1207 { 1208 free (e); 1209 clear_split_rec (&oprec); 1210 clear_insn_templ (t); 1211 return FALSE; 1212 } 1213 } 1214 else 1215 e->operand_name = enter_opname (oprec.vec[i]); 1216 1217 *t->operand_map.tail = e; 1218 t->operand_map.tail = &e->next; 1219 } 1220 clear_split_rec (&oprec); 1221 return TRUE; 1222 } 1223 1224 1225 static bfd_boolean 1226 parse_precond (const char *s, precond_e *precond) 1227 { 1228 /* All preconditions are currently of the form: 1229 a == b or a != b or a == k (where k is a constant). 1230 Later we may use some special functions like DENSITY == 1 1231 to identify when density is available. */ 1232 1233 const char *p = s; 1234 int len; 1235 precond->opname1 = NULL; 1236 precond->opval1 = 0; 1237 precond->cmpop = OP_EQUAL; 1238 precond->opname2 = NULL; 1239 precond->opval2 = 0; 1240 precond->next = NULL; 1241 1242 p = skip_white (p); 1243 1244 len = strcspn (p, " !="); 1245 1246 if (len == 0) 1247 return FALSE; 1248 1249 precond->opname1 = enter_opname_n (p, len); 1250 p = p + len; 1251 p = skip_white (p); 1252 1253 /* Check for "==" and "!=". */ 1254 if (strncmp (p, "==", 2) == 0) 1255 precond->cmpop = OP_EQUAL; 1256 else if (strncmp (p, "!=", 2) == 0) 1257 precond->cmpop = OP_NOTEQUAL; 1258 else 1259 return FALSE; 1260 1261 p = p + 2; 1262 p = skip_white (p); 1263 1264 /* No trailing whitespace from earlier parsing. */ 1265 if (p[0] >= '0' && p[0] <= '9') 1266 { 1267 unsigned val; 1268 if (parse_constant (p, &val)) 1269 precond->opval2 = val; 1270 else 1271 return FALSE; 1272 } 1273 else 1274 precond->opname2 = enter_opname (p); 1275 return TRUE; 1276 } 1277 1278 1279 static void 1280 clear_req_or_option_list (ReqOrOption **r_p) 1281 { 1282 if (*r_p == NULL) 1283 return; 1284 1285 free ((*r_p)->option_name); 1286 clear_req_or_option_list (&(*r_p)->next); 1287 *r_p = NULL; 1288 } 1289 1290 1291 static void 1292 clear_req_option_list (ReqOption **r_p) 1293 { 1294 if (*r_p == NULL) 1295 return; 1296 1297 clear_req_or_option_list (&(*r_p)->or_option_terms); 1298 clear_req_option_list (&(*r_p)->next); 1299 *r_p = NULL; 1300 } 1301 1302 1303 static ReqOrOption * 1304 clone_req_or_option_list (ReqOrOption *req_or_option) 1305 { 1306 ReqOrOption *new_req_or_option; 1307 1308 if (req_or_option == NULL) 1309 return NULL; 1310 1311 new_req_or_option = XNEW (ReqOrOption); 1312 new_req_or_option->option_name = xstrdup (req_or_option->option_name); 1313 new_req_or_option->is_true = req_or_option->is_true; 1314 new_req_or_option->next = NULL; 1315 new_req_or_option->next = clone_req_or_option_list (req_or_option->next); 1316 return new_req_or_option; 1317 } 1318 1319 1320 static ReqOption * 1321 clone_req_option_list (ReqOption *req_option) 1322 { 1323 ReqOption *new_req_option; 1324 1325 if (req_option == NULL) 1326 return NULL; 1327 1328 new_req_option = XNEW (ReqOption); 1329 new_req_option->or_option_terms = NULL; 1330 new_req_option->next = NULL; 1331 new_req_option->or_option_terms = 1332 clone_req_or_option_list (req_option->or_option_terms); 1333 new_req_option->next = clone_req_option_list (req_option->next); 1334 return new_req_option; 1335 } 1336 1337 1338 static bfd_boolean 1339 parse_option_cond (const char *s, ReqOption *option) 1340 { 1341 int i; 1342 split_rec option_term_rec; 1343 1344 /* All option or conditions are of the form: 1345 optionA + no-optionB + ... 1346 "Ands" are divided by "?". */ 1347 1348 init_split_rec (&option_term_rec); 1349 split_string (&option_term_rec, s, '+', TRUE); 1350 1351 if (option_term_rec.count == 0) 1352 { 1353 clear_split_rec (&option_term_rec); 1354 return FALSE; 1355 } 1356 1357 for (i = 0; i < option_term_rec.count; i++) 1358 { 1359 char *option_name = option_term_rec.vec[i]; 1360 bfd_boolean is_true = TRUE; 1361 ReqOrOption *req; 1362 ReqOrOption **r_p; 1363 1364 if (strncmp (option_name, "no-", 3) == 0) 1365 { 1366 option_name = xstrdup (&option_name[3]); 1367 is_true = FALSE; 1368 } 1369 else 1370 option_name = xstrdup (option_name); 1371 1372 req = XNEW (ReqOrOption); 1373 req->option_name = option_name; 1374 req->is_true = is_true; 1375 req->next = NULL; 1376 1377 /* Append to list. */ 1378 for (r_p = &option->or_option_terms; (*r_p) != NULL; 1379 r_p = &(*r_p)->next) 1380 ; 1381 (*r_p) = req; 1382 } 1383 return TRUE; 1384 } 1385 1386 1387 /* Parse a string like: 1388 "insn op1, op2, op3, op4 | op1 != op2 | op2 == op3 | op4 == 1". 1389 I.E., instruction "insn" with 4 operands where operand 1 and 2 are not 1390 the same and operand 2 and 3 are the same and operand 4 is 1. 1391 1392 or: 1393 1394 "insn op1 | op1 == 1 / density + boolean / no-useroption". 1395 i.e. instruction "insn" with 1 operands where operand 1 is 1 1396 when "density" or "boolean" options are available and 1397 "useroption" is not available. 1398 1399 Because the current implementation of this parsing scheme uses 1400 split_string, it requires that '|' and '?' are only used as 1401 delimiters for predicates and required options. */ 1402 1403 static bfd_boolean 1404 parse_insn_pattern (const char *in, insn_pattern *insn) 1405 { 1406 split_rec rec; 1407 split_rec optionrec; 1408 int i; 1409 1410 init_insn_pattern (insn); 1411 1412 init_split_rec (&optionrec); 1413 split_string (&optionrec, in, '?', TRUE); 1414 if (optionrec.count == 0) 1415 { 1416 clear_split_rec (&optionrec); 1417 return FALSE; 1418 } 1419 1420 init_split_rec (&rec); 1421 1422 split_string (&rec, optionrec.vec[0], '|', TRUE); 1423 1424 if (rec.count == 0) 1425 { 1426 clear_split_rec (&rec); 1427 clear_split_rec (&optionrec); 1428 return FALSE; 1429 } 1430 1431 if (!parse_insn_templ (rec.vec[0], &insn->t)) 1432 { 1433 clear_split_rec (&rec); 1434 clear_split_rec (&optionrec); 1435 return FALSE; 1436 } 1437 1438 for (i = 1; i < rec.count; i++) 1439 { 1440 precond_e *cond = XNEW (precond_e); 1441 1442 if (!parse_precond (rec.vec[i], cond)) 1443 { 1444 clear_split_rec (&rec); 1445 clear_split_rec (&optionrec); 1446 clear_insn_pattern (insn); 1447 return FALSE; 1448 } 1449 1450 /* Append the condition. */ 1451 *insn->preconds.tail = cond; 1452 insn->preconds.tail = &cond->next; 1453 } 1454 1455 for (i = 1; i < optionrec.count; i++) 1456 { 1457 /* Handle the option conditions. */ 1458 ReqOption **r_p; 1459 ReqOption *req_option = XNEW (ReqOption); 1460 req_option->or_option_terms = NULL; 1461 req_option->next = NULL; 1462 1463 if (!parse_option_cond (optionrec.vec[i], req_option)) 1464 { 1465 clear_split_rec (&rec); 1466 clear_split_rec (&optionrec); 1467 clear_insn_pattern (insn); 1468 clear_req_option_list (&req_option); 1469 return FALSE; 1470 } 1471 1472 /* Append the condition. */ 1473 for (r_p = &insn->options; (*r_p) != NULL; r_p = &(*r_p)->next) 1474 ; 1475 1476 (*r_p) = req_option; 1477 } 1478 1479 clear_split_rec (&rec); 1480 clear_split_rec (&optionrec); 1481 return TRUE; 1482 } 1483 1484 1485 static bfd_boolean 1486 parse_insn_repl (const char *in, insn_repl *r_p) 1487 { 1488 /* This is a list of instruction templates separated by ';'. */ 1489 split_rec rec; 1490 int i; 1491 1492 split_string (&rec, in, ';', TRUE); 1493 1494 for (i = 0; i < rec.count; i++) 1495 { 1496 insn_repl_e *e = XNEW (insn_repl_e); 1497 1498 e->next = NULL; 1499 1500 if (!parse_insn_templ (rec.vec[i], &e->t)) 1501 { 1502 free (e); 1503 clear_insn_repl (r_p); 1504 return FALSE; 1505 } 1506 *r_p->tail = e; 1507 r_p->tail = &e->next; 1508 } 1509 return TRUE; 1510 } 1511 1512 1513 static bfd_boolean 1514 transition_applies (insn_pattern *initial_insn, 1515 const char *from_string ATTRIBUTE_UNUSED, 1516 const char *to_string ATTRIBUTE_UNUSED) 1517 { 1518 ReqOption *req_option; 1519 1520 for (req_option = initial_insn->options; 1521 req_option != NULL; 1522 req_option = req_option->next) 1523 { 1524 ReqOrOption *req_or_option = req_option->or_option_terms; 1525 1526 if (req_or_option == NULL 1527 || req_or_option->next != NULL) 1528 continue; 1529 1530 if (strncmp (req_or_option->option_name, "IsaUse", 6) == 0) 1531 { 1532 bfd_boolean option_available = FALSE; 1533 char *option_name = req_or_option->option_name + 6; 1534 if (!strcmp (option_name, "DensityInstruction")) 1535 option_available = (XCHAL_HAVE_DENSITY == 1); 1536 else if (!strcmp (option_name, "L32R")) 1537 option_available = (XCHAL_HAVE_L32R == 1); 1538 else if (!strcmp (option_name, "Const16")) 1539 option_available = (XCHAL_HAVE_CONST16 == 1); 1540 else if (!strcmp (option_name, "Loops")) 1541 option_available = (XCHAL_HAVE_LOOPS == 1); 1542 else if (!strcmp (option_name, "WideBranches")) 1543 option_available 1544 = (XCHAL_HAVE_WIDE_BRANCHES == 1 && produce_flix == FLIX_ALL); 1545 else if (!strcmp (option_name, "PredictedBranches")) 1546 option_available 1547 = (XCHAL_HAVE_PREDICTED_BRANCHES == 1 1548 && produce_flix == FLIX_ALL); 1549 else if (!strcmp (option_name, "Booleans")) 1550 option_available = (XCHAL_HAVE_BOOLEANS == 1); 1551 else 1552 as_warn (_("invalid configuration option '%s' in transition rule '%s'"), 1553 req_or_option->option_name, from_string); 1554 if ((option_available ^ req_or_option->is_true) != 0) 1555 return FALSE; 1556 } 1557 else if (strcmp (req_or_option->option_name, "realnop") == 0) 1558 { 1559 bfd_boolean nop_available = 1560 (xtensa_opcode_lookup (xtensa_default_isa, "nop") 1561 != XTENSA_UNDEFINED); 1562 if ((nop_available ^ req_or_option->is_true) != 0) 1563 return FALSE; 1564 } 1565 } 1566 return TRUE; 1567 } 1568 1569 1570 static bfd_boolean 1571 wide_branch_opcode (const char *opcode_name, 1572 const char *suffix, 1573 xtensa_opcode *popcode) 1574 { 1575 xtensa_isa isa = xtensa_default_isa; 1576 xtensa_opcode opcode; 1577 static char wbr_name_buf[20]; 1578 1579 if (strncmp (opcode_name, "WIDE.", 5) != 0) 1580 return FALSE; 1581 1582 strcpy (wbr_name_buf, opcode_name + 5); 1583 strcat (wbr_name_buf, suffix); 1584 opcode = xtensa_opcode_lookup (isa, wbr_name_buf); 1585 if (opcode != XTENSA_UNDEFINED) 1586 { 1587 *popcode = opcode; 1588 return TRUE; 1589 } 1590 1591 return FALSE; 1592 } 1593 1594 1595 static TransitionRule * 1596 build_transition (insn_pattern *initial_insn, 1597 insn_repl *replace_insns, 1598 const char *from_string, 1599 const char *to_string) 1600 { 1601 TransitionRule *tr = NULL; 1602 xtensa_opcode opcode; 1603 xtensa_isa isa = xtensa_default_isa; 1604 BuildInstr *literal_bi; 1605 1606 opname_map_e *op1; 1607 opname_map_e *op2; 1608 1609 precond_e *precond; 1610 insn_repl_e *r; 1611 1612 if (!wide_branch_opcode (initial_insn->t.opcode_name, ".w18", &opcode) 1613 && !wide_branch_opcode (initial_insn->t.opcode_name, ".w15", &opcode)) 1614 opcode = xtensa_opcode_lookup (isa, initial_insn->t.opcode_name); 1615 1616 if (opcode == XTENSA_UNDEFINED) 1617 { 1618 /* It is OK to not be able to translate some of these opcodes. */ 1619 return NULL; 1620 } 1621 1622 1623 if (xtensa_opcode_num_operands (isa, opcode) 1624 != insn_templ_operand_count (&initial_insn->t)) 1625 { 1626 /* This is also OK because there are opcodes that 1627 have different numbers of operands on different 1628 architecture variations. */ 1629 return NULL; 1630 } 1631 1632 tr = XNEW (TransitionRule); 1633 tr->opcode = opcode; 1634 tr->conditions = NULL; 1635 tr->to_instr = NULL; 1636 1637 /* Build the conditions. First, equivalent operand condition.... */ 1638 for (op1 = initial_insn->t.operand_map.head; op1 != NULL; op1 = op1->next) 1639 { 1640 for (op2 = op1->next; op2 != NULL; op2 = op2->next) 1641 { 1642 if (same_operand_name (op1, op2)) 1643 { 1644 append_value_condition (tr, OP_EQUAL, 1645 op1->operand_num, op2->operand_num); 1646 } 1647 } 1648 } 1649 1650 /* Now the condition that an operand value must be a constant.... */ 1651 for (op1 = initial_insn->t.operand_map.head; op1 != NULL; op1 = op1->next) 1652 { 1653 if (op_is_constant (op1)) 1654 { 1655 append_constant_value_condition (tr, 1656 OP_EQUAL, 1657 op1->operand_num, 1658 op_get_constant (op1)); 1659 } 1660 } 1661 1662 1663 /* Now add the explicit preconditions listed after the "|" in the spec. 1664 These are currently very limited, so we do a special case 1665 parse for them. We expect spaces, opname != opname. */ 1666 for (precond = initial_insn->preconds.head; 1667 precond != NULL; 1668 precond = precond->next) 1669 { 1670 op1 = NULL; 1671 op2 = NULL; 1672 1673 if (precond->opname1) 1674 { 1675 op1 = get_opmatch (&initial_insn->t.operand_map, precond->opname1); 1676 if (op1 == NULL) 1677 as_fatal (_("opcode '%s': no bound opname '%s' " 1678 "for precondition in '%s'"), 1679 xtensa_opcode_name (isa, opcode), 1680 precond->opname1, from_string); 1681 } 1682 1683 if (precond->opname2) 1684 { 1685 op2 = get_opmatch (&initial_insn->t.operand_map, precond->opname2); 1686 if (op2 == NULL) 1687 as_fatal (_("opcode '%s': no bound opname '%s' " 1688 "for precondition in %s"), 1689 xtensa_opcode_name (isa, opcode), 1690 precond->opname2, from_string); 1691 } 1692 1693 if (op1 == NULL && op2 == NULL) 1694 as_fatal (_("opcode '%s': precondition only contains " 1695 "constants in '%s'"), 1696 xtensa_opcode_name (isa, opcode), from_string); 1697 else if (op1 != NULL && op2 != NULL) 1698 append_value_condition (tr, precond->cmpop, 1699 op1->operand_num, op2->operand_num); 1700 else if (op2 == NULL) 1701 append_constant_value_condition (tr, precond->cmpop, 1702 op1->operand_num, precond->opval2); 1703 else 1704 append_constant_value_condition (tr, precond->cmpop, 1705 op2->operand_num, precond->opval1); 1706 } 1707 1708 tr->options = clone_req_option_list (initial_insn->options); 1709 1710 /* Generate the replacement instructions. Some of these 1711 "instructions" are actually labels and literals. There can be at 1712 most one literal and at most one label. A literal must be defined 1713 (e.g., "LITERAL %imm") before use (e.g., "%LITERAL"). The labels 1714 can be used before they are defined. Also there are a number of 1715 special operands (e.g., HI24S). */ 1716 1717 literal_bi = NULL; 1718 for (r = replace_insns->head; r != NULL; r = r->next) 1719 { 1720 BuildInstr *bi; 1721 const char *opcode_name; 1722 int operand_count; 1723 opname_map_e *op; 1724 const char *fn_name; 1725 const char *operand_arg_name; 1726 1727 bi = XNEW (BuildInstr); 1728 append_build_insn (tr, bi); 1729 1730 bi->opcode = XTENSA_UNDEFINED; 1731 bi->ops = NULL; 1732 bi->next = NULL; 1733 1734 opcode_name = r->t.opcode_name; 1735 operand_count = insn_templ_operand_count (&r->t); 1736 1737 if (strcmp (opcode_name, "LITERAL") == 0) 1738 { 1739 bi->typ = INSTR_LITERAL_DEF; 1740 if (operand_count != 1) 1741 as_fatal (_("expected one operand for generated literal")); 1742 literal_bi = bi; 1743 } 1744 else if (strcmp (opcode_name, "LABEL") == 0) 1745 { 1746 bi->typ = INSTR_LABEL_DEF; 1747 if (operand_count != 0) 1748 as_fatal (_("expected 0 operands for generated label")); 1749 } 1750 else 1751 { 1752 bi->typ = INSTR_INSTR; 1753 if (wide_branch_opcode (opcode_name, ".w18", &bi->opcode) 1754 || wide_branch_opcode (opcode_name, ".w15", &bi->opcode)) 1755 opcode_name = xtensa_opcode_name (isa, bi->opcode); 1756 else 1757 bi->opcode = xtensa_opcode_lookup (isa, opcode_name); 1758 1759 if (bi->opcode == XTENSA_UNDEFINED) 1760 { 1761 as_warn (_("invalid opcode '%s' in transition rule '%s'"), 1762 opcode_name, to_string); 1763 return NULL; 1764 } 1765 1766 /* Check for the right number of ops. */ 1767 if (xtensa_opcode_num_operands (isa, bi->opcode) 1768 != (int) operand_count) 1769 as_fatal (_("opcode '%s': replacement does not have %d ops"), 1770 opcode_name, 1771 xtensa_opcode_num_operands (isa, bi->opcode)); 1772 } 1773 1774 for (op = r->t.operand_map.head; op != NULL; op = op->next) 1775 { 1776 unsigned idnum; 1777 1778 if (op_is_constant (op)) 1779 append_constant_op (bi, op->operand_num, op_get_constant (op)); 1780 else if (strcmp (op->operand_name, "%LITERAL") == 0) 1781 { 1782 if (! literal_bi || ! literal_bi->ops || literal_bi->ops->next) 1783 as_fatal (_("opcode '%s': cannot find literal definition"), 1784 opcode_name); 1785 append_literal_op (bi, op->operand_num, 1786 literal_bi->ops->op_data); 1787 } 1788 else if (strcmp (op->operand_name, "%LABEL") == 0) 1789 append_label_op (bi, op->operand_num); 1790 else if (op->operand_name[0] == 'a' 1791 && parse_constant (op->operand_name + 1, &idnum)) 1792 append_constant_op (bi, op->operand_num, idnum); 1793 else if (op->operand_name[0] == '%') 1794 { 1795 opname_map_e *orig_op; 1796 orig_op = get_opmatch (&initial_insn->t.operand_map, 1797 op->operand_name); 1798 if (orig_op == NULL) 1799 as_fatal (_("opcode %s: unidentified operand '%s' in '%s'"), 1800 opcode_name, op->operand_name, to_string); 1801 append_field_op (bi, op->operand_num, orig_op->operand_num); 1802 } 1803 else if (strcmp (op->operand_name, "FREEREG") == 0) 1804 { 1805 append_user_fn_field_op (bi, op->operand_num, OP_FREEREG, 0); 1806 } 1807 else if (parse_special_fn (op->operand_name, 1808 &fn_name, &operand_arg_name)) 1809 { 1810 opname_map_e *orig_op; 1811 OpType typ = OP_CONSTANT; 1812 1813 if (strcmp (fn_name, "LOW8") == 0) 1814 typ = OP_OPERAND_LOW8; 1815 else if (strcmp (fn_name, "HI24S") == 0) 1816 typ = OP_OPERAND_HI24S; 1817 else if (strcmp (fn_name, "F32MINUS") == 0) 1818 typ = OP_OPERAND_F32MINUS; 1819 else if (strcmp (fn_name, "LOW16U") == 0) 1820 typ = OP_OPERAND_LOW16U; 1821 else if (strcmp (fn_name, "HI16U") == 0) 1822 typ = OP_OPERAND_HI16U; 1823 else 1824 as_fatal (_("unknown user-defined function %s"), fn_name); 1825 1826 orig_op = get_opmatch (&initial_insn->t.operand_map, 1827 operand_arg_name); 1828 if (orig_op == NULL) 1829 as_fatal (_("opcode %s: unidentified operand '%s' in '%s'"), 1830 opcode_name, op->operand_name, to_string); 1831 append_user_fn_field_op (bi, op->operand_num, 1832 typ, orig_op->operand_num); 1833 } 1834 else 1835 as_fatal (_("opcode %s: could not parse operand '%s' in '%s'"), 1836 opcode_name, op->operand_name, to_string); 1837 } 1838 } 1839 1840 return tr; 1841 } 1842 1843 1844 static TransitionTable * 1845 build_transition_table (const string_pattern_pair *transitions, 1846 int transition_count, 1847 transition_cmp_fn cmp) 1848 { 1849 TransitionTable *table = NULL; 1850 int num_opcodes = xtensa_isa_num_opcodes (xtensa_default_isa); 1851 int i, tnum; 1852 1853 if (table != NULL) 1854 return table; 1855 1856 /* Otherwise, build it now. */ 1857 table = XNEW (TransitionTable); 1858 table->num_opcodes = num_opcodes; 1859 table->table = XNEWVEC (TransitionList *, num_opcodes); 1860 1861 for (i = 0; i < num_opcodes; i++) 1862 table->table[i] = NULL; 1863 1864 for (tnum = 0; tnum < transition_count; tnum++) 1865 { 1866 const char *from_string = transitions[tnum].pattern; 1867 const char *to_string = transitions[tnum].replacement; 1868 1869 insn_pattern initial_insn; 1870 insn_repl replace_insns; 1871 TransitionRule *tr; 1872 1873 init_insn_pattern (&initial_insn); 1874 if (!parse_insn_pattern (from_string, &initial_insn)) 1875 as_fatal (_("could not parse INSN_PATTERN '%s'"), from_string); 1876 1877 init_insn_repl (&replace_insns); 1878 if (!parse_insn_repl (to_string, &replace_insns)) 1879 as_fatal (_("could not parse INSN_REPL '%s'"), to_string); 1880 1881 if (transition_applies (&initial_insn, from_string, to_string)) 1882 { 1883 tr = build_transition (&initial_insn, &replace_insns, 1884 from_string, to_string); 1885 if (tr) 1886 append_transition (table, tr->opcode, tr, cmp); 1887 else 1888 { 1889 #if TENSILICA_DEBUG 1890 as_warn (_("could not build transition for %s => %s"), 1891 from_string, to_string); 1892 #endif 1893 } 1894 } 1895 1896 clear_insn_repl (&replace_insns); 1897 clear_insn_pattern (&initial_insn); 1898 } 1899 return table; 1900 } 1901 1902 1903 extern TransitionTable * 1905 xg_build_widen_table (transition_cmp_fn cmp) 1906 { 1907 static TransitionTable *table = NULL; 1908 if (table == NULL) 1909 table = build_transition_table (widen_spec_list, WIDEN_COUNT, cmp); 1910 return table; 1911 } 1912 1913 1914 extern TransitionTable * 1915 xg_build_simplify_table (transition_cmp_fn cmp) 1916 { 1917 static TransitionTable *table = NULL; 1918 if (table == NULL) 1919 table = build_transition_table (simplify_spec_list, SIMPLIFY_COUNT, cmp); 1920 return table; 1921 } 1922