home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / vbcc / pasm / instructions.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-17  |  40.9 KB  |  1,252 lines
  1. /* $VER: pasm instructions.c V0.8 (14.02.98)
  2.  *
  3.  * This file is part of pasm, a portable PowerPC assembler.
  4.  * Copyright (c) 1997-98  Frank Wille
  5.  *
  6.  * pasm is freeware and part of the portable and retargetable ANSI C
  7.  * compiler vbcc, copyright (c) 1995-98 by Volker Barthelmann.
  8.  * pasm may be freely redistributed as long as no modifications are
  9.  * made and nothing is charged for it. Non-commercial usage is allowed
  10.  * without any restrictions.
  11.  * EVERY PRODUCT OR PROGRAM DERIVED DIRECTLY FROM MY SOURCE MAY NOT BE
  12.  * SOLD COMMERCIALLY WITHOUT PERMISSION FROM THE AUTHOR.
  13.  *
  14.  *
  15.  * v0.8 (14.02.98) phx
  16.  *      Alignment list for each section. This fixes the problems
  17.  *      with optimizations.
  18.  * V0.7 (02.01.98) phx
  19.  *      Implemented optimization OPT_FAR_BRANCH.
  20.  * v0.6 (30.10.97) phx
  21.  *      No more warnings for val@l(rA), where val is > 0x7fff.
  22.  *      Warnings for optional, 64-bit and supervisor instructions
  23.  *      can be suppressed.
  24.  * v0.5 (03.10.97) phx
  25.  *      Auto-converting (rA) into 0(rA) had lead to conflicts with terms.
  26.  *      For example: (x+y)(rA)
  27.  * v0.4 (05.07.97) phx
  28.  *      AA bit in BC instructions is set to allow correct EHF reloction
  29.  *      (by using AmigaDOS HUNK_RELRELOC16. This should be no problem,
  30.  *      because absolute branches are not supported by EHF anyway.
  31.  *      Branch prediction with BCA didn't work correctly.
  32.  *      Relative branches into other sections are allowed, but the
  33.  *      user will be warned, because not all object formats / linkers
  34.  *      support it.
  35.  *      Omitting zero in load/store instructions is allowed, e.g.
  36.  *      "rD,(rA)" will be converted into "rD,0(rA)".
  37.  *      R_PPC_TOC16 support for T_DD- and T_DS-type instructions.
  38.  * v0.3 (05.04.97) phx
  39.  *      An external symbol@l/h/ha, used in d(Rn) addressing mode, got
  40.  *      R_PPC_ADDR16 relocation instead R_PPC_ADDR16_LO/HI/HA.
  41.  *      Little-endian support.
  42.  * v0.2 (25.03.97) phx
  43.  *      Writes ELF object for 32-bit PowerPC big-endian. Either absolute
  44.  *      or ELF output format may be selected. ELF is default for all
  45.  *      currently supported platforms. PPCasm supports nine different
  46.  *      relocation types (there are much more...).
  47.  *      Compiles and works also under NetBSD/amiga (68k).
  48.  *      Changed function declaration to 'new style' in all sources
  49.  *      (to avoid problems with '...' for example).
  50.  *      @l/h/ha is allowed for all displacements.
  51.  * v0.1 (11.03.97) phx
  52.  *      First test version with all PowerPC instructions and most
  53.  *      important directives. Only raw, absolute output.
  54.  *      Although all 32- and 64-bit PowerPC instructions are imple-
  55.  *      mented, too few are really tested till now. I'm expecting many
  56.  *      bugs in this long list.
  57.  *      'la' is the only extended mnemonic, which was implemented as a
  58.  *      real instruction and not by a macro. It is possible to imple-
  59.  *      ment all extended mnemonics here, but it would be much work.
  60.  *      Maybe later, to improve speed. ;)
  61.  * v0.0 (21.02.97) phx
  62.  *      File created.
  63.  */
  64.  
  65.  
  66. #define INSTRUCTIONS_C
  67. #include "ppcasm.h"
  68.  
  69.  
  70. void instr(struct GlobalVars *,struct ParsedLine *);
  71. char *check_comma(char *);
  72. void pcadd(struct GlobalVars *,unsigned long);
  73. void store_byte(struct GlobalVars *,uint8);
  74. void store_half(struct GlobalVars *,uint16);
  75. void store_word(struct GlobalVars *,uint32);
  76. void store_float(struct GlobalVars *,double);
  77. void store_double(struct GlobalVars *,double);
  78. void store_space(struct GlobalVars *,unsigned long);
  79.  
  80. static void opt_far_branch(struct GlobalVars *,struct ParsedLine *,
  81.                            uint32 *,uint32 *,int32 *,char *);
  82. static void swapops(uint32 *,uint32 *);
  83. static int count_operands(struct GlobalVars *,char *);
  84. static bool chk_regindir(char *);
  85. static void move_symbols(struct GlobalVars *,uint32,int32);
  86. static void move_aligned_symbols_offset(struct GlobalVars *,
  87.                                         struct AlignPoint *,uint32,int32);
  88. static void move_aligned_symbols_all(struct GlobalVars *gv,
  89.                                      struct AlignPoint *ap,int32);
  90.  
  91.  
  92.  
  93. struct CPUInstr instructions[] = {
  94.   /* standard PowerPC instruction set */
  95.   { 0,"add",0,T_X,31,0,0,(0<<10)+(266<<1)+0 },
  96.   { 0,"add.",0,T_X,31,0,0,(0<<10)+(266<<1)+1 },
  97.   { 0,"addo",0,T_X,31,0,0,(1<<10)+(266<<1)+0 },
  98.   { 0,"addo.",0,T_X,31,0,0,(1<<10)+(266<<1)+1 },
  99.   { 0,"addc",0,T_X,31,0,0,(0<<10)+(10<<1)+0 },
  100.   { 0,"addc.",0,T_X,31,0,0,(0<<10)+(10<<1)+1 },
  101.   { 0,"addco",0,T_X,31,0,0,(1<<10)+(10<<1)+0 },
  102.   { 0,"addco.",0,T_X,31,0,0,(1<<10)+(10<<1)+1 },
  103.   { 0,"adde",0,T_X,31,0,0,(0<<10)+(138<<1)+0 },
  104.   { 0,"adde.",0,T_X,31,0,0,(0<<10)+(138<<1)+1 },
  105.   { 0,"addeo",0,T_X,31,0,0,(1<<10)+(138<<1)+0 },
  106.   { 0,"addeo.",0,T_X,31,0,0,(1<<10)+(138<<1)+1 },
  107.   { 0,"addi",F_SIGNED,T_DI,14,0,0,0 },
  108.   { 0,"addic",F_SIGNED,T_DI,12,0,0,0 },
  109.   { 0,"addic.",F_SIGNED,T_DI,13,0,0,0 },
  110.   { 0,"addis",F_SIGNED,T_DI,15,0,0,0 },
  111.   { 0,"addme",F_SUPP_B,T_X,31,0,0,(0<<10)+(234<<1)+0 },
  112.   { 0,"addme.",F_SUPP_B,T_X,31,0,0,(0<<10)+(234<<1)+1 },
  113.   { 0,"addmeo",F_SUPP_B,T_X,31,0,0,(1<<10)+(234<<1)+0 },
  114.   { 0,"addmeo.",F_SUPP_B,T_X,31,0,0,(1<<10)+(234<<1)+1 },
  115.   { 0,"addze",F_SUPP_B,T_X,31,0,0,(0<<10)+(202<<1)+0 },
  116.   { 0,"addze.",F_SUPP_B,T_X,31,0,0,(0<<10)+(202<<1)+1 },
  117.   { 0,"addzeo",F_SUPP_B,T_X,31,0,0,(1<<10)+(202<<1)+0 },
  118.   { 0,"addzeo.",F_SUPP_B,T_X,31,0,0,(1<<10)+(202<<1)+1 },
  119.   { 0,"and",F_SWAP,T_X,31,0,0,(28<<1)+0 },
  120.   { 0,"and.",F_SWAP,T_X,31,0,0,(28<<1)+1 },
  121.   { 0,"andc",F_SWAP,T_X,31,0,0,(60<<1)+0 },
  122.   { 0,"andc.",F_SWAP,T_X,31,0,0,(60<<1)+1 },
  123.   { 0,"andi.",F_SWAP,T_DI,28,0,0,0 },
  124.   { 0,"andis.",F_SWAP,T_DI,29,0,0,0 },
  125.   { 0,"b",F_SIGNED,T_I,18,0,0,0 },
  126.   { 0,"bl",F_SIGNED,T_I,18,0,0,1 },
  127.   { 0,"ba",0,T_I,18,0,0,2 },
  128.   { 0,"bla",0,T_I,18,0,0,3 },
  129.   { 0,"bc",F_SIGNED,T_B,16,0,0,0 },
  130.   { 0,"bcl",F_SIGNED,T_B,16,0,0,1 },
  131.   { 0,"bca",0,T_B,16,0,0,2 },
  132.   { 0,"bcla",0,T_B,16,0,0,3 },
  133.   { 0,"bcctr",0,T_XLB,19,0,0,(528<<1)+0 },
  134.   { 0,"bcctrl",0,T_XLB,19,0,0,(528<<1)+1 },
  135.   { 0,"bclr",0,T_XLB,19,0,0,(16<<1)+0 },
  136.   { 0,"bclrl",0,T_XLB,19,0,0,(16<<1)+1 },
  137.   { 0,"cmp",0,T_CMP,31,0,0,(0<<1) },
  138.   { 0,"cmpl",0,T_CMP,31,0,0,(32<<1) },
  139.   { 0,"cmpi",F_SIGNED|F_SUPP_B,T_CMP,11,0,0,0 },
  140.   { 0,"cmpli",F_SUPP_B,T_CMP,10,0,0,0 },
  141.   { 0,"cntlzd",F_SWAP|F_SUPP_B|F_64BIT,T_X,31,0,0,(58<<1)+0 },
  142.   { 0,"cntlzd.",F_SWAP|F_SUPP_B|F_64BIT,T_X,31,0,0,(58<<1)+1 },
  143.   { 0,"cntlzw",F_SWAP|F_SUPP_B,T_X,31,0,0,(26<<1)+0 },
  144.   { 0,"cntlzw.",F_SWAP|F_SUPP_B,T_X,31,0,0,(26<<1)+1 },
  145.   { 0,"crand",0,T_X,19,0,0,(257<<1) },
  146.   { 0,"crandc",0,T_X,19,0,0,(129<<1) },
  147.   { 0,"creqv",0,T_X,19,0,0,(289<<1) },
  148.   { 0,"crnand",0,T_X,19,0,0,(225<<1) },
  149.   { 0,"crnor",0,T_X,19,0,0,(33<<1) },
  150.   { 0,"cror",0,T_X,19,0,0,(449<<1) },
  151.   { 0,"crorc",0,T_X,19,0,0,(417<<1) },
  152.   { 0,"crxor",0,T_X,19,0,0,(193<<1) },
  153.   { 0,"dcbf",F_SUPP_D,T_X,31,0,0,(86<<1) },
  154.   { 0,"dcbi",F_SUPP_D|F_SUPER,T_X,31,0,0,(470<<1) },
  155.   { 0,"dcbst",F_SUPP_D,T_X,31,0,0,(54<<1) },
  156.   { 0,"dcbt",F_SUPP_D,T_X,31,0,0,(278<<1) },
  157.   { 0,"dcbtst",F_SUPP_D,T_X,31,0,0,(246<<1) },
  158.   { 0,"dcbz",F_SUPP_D,T_X,31,0,0,(1014<<1) },
  159.   { 0,"divd",F_64BIT,T_X,31,0,0,(0<<10)+(489<<1)+0 },
  160.   { 0,"divd.",F_64BIT,T_X,31,0,0,(0<<10)+(489<<1)+1 },
  161.   { 0,"divdo",F_64BIT,T_X,31,0,0,(1<<10)+(489<<1)+0 },
  162.   { 0,"divdo.",F_64BIT,T_X,31,0,0,(1<<10)+(489<<1)+1 },
  163.   { 0,"divdu",F_64BIT,T_X,31,0,0,(0<<10)+(457<<1)+0 },
  164.   { 0,"divdu.",F_64BIT,T_X,31,0,0,(0<<10)+(457<<1)+1 },
  165.   { 0,"divduo",F_64BIT,T_X,31,0,0,(1<<10)+(457<<1)+0 },
  166.   { 0,"divduo.",F_64BIT,T_X,31,0,0,(1<<10)+(457<<1)+1 },
  167.   { 0,"divw",0,T_X,31,0,0,(0<<10)+(491<<1)+0 },
  168.   { 0,"divw.",0,T_X,31,0,0,(0<<10)+(491<<1)+1 },
  169.   { 0,"divwo",0,T_X,31,0,0,(1<<10)+(491<<1)+0 },
  170.   { 0,"divwo.",0,T_X,31,0,0,(1<<10)+(491<<1)+1 },
  171.   { 0,"divwu",0,T_X,31,0,0,(0<<10)+(459<<1)+0 },
  172.   { 0,"divwu.",0,T_X,31,0,0,(0<<10)+(459<<1)+1 },
  173.   { 0,"divwuo",0,T_X,31,0,0,(1<<10)+(459<<1)+0 },
  174.   { 0,"divwuo.",0,T_X,31,0,0,(1<<10)+(459<<1)+1 },
  175.   { 0,"eciwx",0,T_X,31,0,0,(310<<1) },
  176.   { 0,"ecowx",0,T_X,31,0,0,(438<<1) },
  177.   { 0,"eieio",F_SUPP_D|F_SUPP_A|F_SUPP_B,T_X,31,0,0,(854<<1) },
  178.   { 0,"eqv",F_SWAP,T_X,31,0,0,(284<<1)+0 },
  179.   { 0,"eqv.",F_SWAP,T_X,31,0,0,(284<<1)+0 },
  180.   { 0,"extsb",F_SWAP|F_SUPP_B,T_X,31,0,0,(954<<1)+0 },
  181.   { 0,"extsb.",F_SWAP|F_SUPP_B,T_X,31,0,0,(954<<1)+1 },
  182.   { 0,"extsh",F_SWAP|F_SUPP_B,T_X,31,0,0,(922<<1)+0 },
  183.   { 0,"extsh.",F_SWAP|F_SUPP_B,T_X,31,0,0,(922<<1)+1 },
  184.   { 0,"extsw",F_SWAP|F_SUPP_B|F_64BIT,T_X,31,0,0,(986<<1)+0 },
  185.   { 0,"extsw.",F_SWAP|F_SUPP_B|F_64BIT,T_X,31,0,0,(986<<1)+1 },
  186.   { 0,"fabs",F_SUPP_A,T_X,63,0,0,(264<<1)+0 },
  187.   { 0,"fabs.",F_SUPP_A,T_X,63,0,0,(264<<1)+1 },
  188.   { 0,"fadd",F_SUPP_C,T_A,63,0,0,(21<<1)+0 },
  189.   { 0,"fadd.",F_SUPP_C,T_A,63,0,0,(21<<1)+1 },
  190.   { 0,"fadds",F_SUPP_C,T_A,59,0,0,(21<<1)+0 },
  191.   { 0,"fadds.",F_SUPP_C,T_A,59,0,0,(21<<1)+1 },
  192.   { 0,"fcfid",F_SUPP_A|F_64BIT,T_X,63,0,0,(846<<1)+0 },
  193.   { 0,"fcfid.",F_SUPP_A|F_64BIT,T_X,63,0,0,(846<<1)+1 },
  194.   { 0,"fcmpo",F_CRF_D,T_X,63,0,0,(32<<1) },
  195.   { 0,"fcmpu",F_CRF_D,T_X,63,0,0,(0<<1) },
  196.   { 0,"fctid",F_SUPP_A|F_64BIT,T_X,63,0,0,(814<<1)+0 },
  197.   { 0,"fctid.",F_SUPP_A|F_64BIT,T_X,63,0,0,(814<<1)+1 },
  198.   { 0,"fctidz",F_SUPP_A|F_64BIT,T_X,63,0,0,(815<<1)+0 },
  199.   { 0,"fctidz.",F_SUPP_A|F_64BIT,T_X,63,0,0,(815<<1)+1 },
  200.   { 0,"fctiw",F_SUPP_A,T_X,63,0,0,(14<<1)+0 },
  201.   { 0,"fctiw.",F_SUPP_A,T_X,63,0,0,(14<<1)+1 },
  202.   { 0,"fctiwz",F_SUPP_A,T_X,63,0,0,(15<<1)+0 },
  203.   { 0,"fctiwz.",F_SUPP_A,T_X,63,0,0,(15<<1)+1 },
  204.   { 0,"fdiv",F_SUPP_C,T_A,63,0,0,(18<<1)+0 },
  205.   { 0,"fdiv.",F_SUPP_C,T_A,63,0,0,(18<<1)+1 },
  206.   { 0,"fdivs",F_SUPP_C,T_A,59,0,0,(18<<1)+0 },
  207.   { 0,"fdivs.",F_SUPP_C,T_A,59,0,0,(18<<1)+1 },
  208.   { 0,"fmadd",0,T_A,63,0,0,(29<<1)+0 },
  209.   { 0,"fmadd.",0,T_A,63,0,0,(29<<1)+1 },
  210.   { 0,"fmadds",0,T_A,59,0,0,(29<<1)+0 },
  211.   { 0,"fmadds.",0,T_A,59,0,0,(29<<1)+1 },
  212.   { 0,"fmr",F_SUPP_A,T_X,63,0,0,(72<<1)+0 },
  213.   { 0,"fmr.",F_SUPP_A,T_X,63,0,0,(72<<1)+1 },
  214.   { 0,"fmsub",0,T_A,63,0,0,(28<<1)+0 },
  215.   { 0,"fmsub.",0,T_A,63,0,0,(28<<1)+1 },
  216.   { 0,"fmsubs",0,T_A,59,0,0,(28<<1)+0 },
  217.   { 0,"fmsubs.",0,T_A,59,0,0,(28<<1)+1 },
  218.   { 0,"fmul",F_SUPP_B,T_A,63,0,0,(25<<1)+0 },
  219.   { 0,"fmul.",F_SUPP_B,T_A,63,0,0,(25<<1)+1 },
  220.   { 0,"fmuls",F_SUPP_B,T_A,59,0,0,(25<<1)+0 },
  221.   { 0,"fmuls.",F_SUPP_B,T_A,59,0,0,(25<<1)+1 },
  222.   { 0,"fnabs",F_SUPP_A,T_X,63,0,0,(136<<1)+0 },
  223.   { 0,"fnabs.",F_SUPP_A,T_X,63,0,0,(136<<1)+1 },
  224.   { 0,"fneg",F_SUPP_A,T_X,63,0,0,(40<<1)+0 },
  225.   { 0,"fneg.",F_SUPP_A,T_X,63,0,0,(40<<1)+1 },
  226.   { 0,"fnmadd",0,T_A,63,0,0,(31<<1)+0 },
  227.   { 0,"fnmadd.",0,T_A,63,0,0,(31<<1)+1 },
  228.   { 0,"fnmadds",0,T_A,59,0,0,(31<<1)+0 },
  229.   { 0,"fnmadds.",0,T_A,59,0,0,(31<<1)+1 },
  230.   { 0,"fnmsub",0,T_A,63,0,0,(30<<1)+0 },
  231.   { 0,"fnmsub.",0,T_A,63,0,0,(30<<1)+1 },
  232.   { 0,"fnmsubs",0,T_A,59,0,0,(30<<1)+0 },
  233.   { 0,"fnmsubs.",0,T_A,59,0,0,(30<<1)+1 },
  234.   { 0,"fres",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,59,0,0,(24<<1)+0 },
  235.   { 0,"fres.",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,59,0,0,(24<<1)+1 },
  236.   { 0,"frsp",F_SUPP_A,T_X,63,0,0,(12<<1)+0 },
  237.   { 0,"frsp.",F_SUPP_A,T_X,63,0,0,(12<<1)+1 },
  238.   { 0,"frsqrte",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,63,0,0,(26<<1)+0 },
  239.   { 0,"frsqrte.",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,63,0,0,(26<<1)+1 },
  240.   { 0,"fsel",F_OPTIONAL,T_A,63,0,0,(23<<1)+0 },
  241.   { 0,"fsel.",F_OPTIONAL,T_A,63,0,0,(23<<1)+1 },
  242.   { 0,"fsqrt",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,63,0,0,(22<<1)+0 },
  243.   { 0,"fsqrt.",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,63,0,0,(22<<1)+1 },
  244.   { 0,"fsqrts",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,59,0,0,(22<<1)+0 },
  245.   { 0,"fsqrts.",F_SUPP_A|F_SUPP_C|F_OPTIONAL,T_A,59,0,0,(22<<1)+1 },
  246.   { 0,"fsub",F_SUPP_C,T_A,63,0,0,(20<<1)+0 },
  247.   { 0,"fsub.",F_SUPP_C,T_A,63,0,0,(20<<1)+1 },
  248.   { 0,"fsubs",F_SUPP_C,T_A,59,0,0,(20<<1)+0 },
  249.   { 0,"fsubs.",F_SUPP_C,T_A,59,0,0,(20<<1)+1 },
  250.   { 0,"icbi",F_SUPP_D,T_X,31,0,0,(982<<1) },
  251.   { 0,"isync",F_SUPP_D|F_SUPP_A|F_SUPP_B,T_X,19,0,0,(150<<1) },
  252.   { 0,"lbz",0,T_DD,34,0,0,0 },
  253.   { 0,"lbzu",0,T_DD,35,0,0,0 },
  254.   { 0,"lbzux",0,T_X,31,0,0,(119<<1) },
  255.   { 0,"lbzx",0,T_X,31,0,0,(87<<1) },
  256.   { 0,"ld",F_64BIT,T_DS,58,0,0,0 },
  257.   { 0,"ldarx",F_64BIT,T_X,31,0,0,(84<<1) },
  258.   { 0,"ldu",F_64BIT,T_DS,58,0,0,1 },
  259.   { 0,"ldux",F_64BIT,T_X,31,0,0,(53<<1) },
  260.   { 0,"ldx",F_64BIT,T_X,31,0,0,(21<<1) },
  261.   { 0,"lfd",0,T_DD,50,0,0,0 },
  262.   { 0,"lfdu",0,T_DD,51,0,0,0 },
  263.   { 0,"lfdux",0,T_X,31,0,0,(631<<1) },
  264.   { 0,"lfdx",0,T_X,31,0,0,(599<<1) },
  265.   { 0,"lfs",0,T_DD,48,0,0,0 },
  266.   { 0,"lfsu",0,T_DD,49,0,0,0 },
  267.   { 0,"lfsux",0,T_X,31,0,0,(567<<1) },
  268.   { 0,"lfsx",0,T_X,31,0,0,(535<<1) },
  269.   { 0,"lha",0,T_DD,42,0,0,0 },
  270.   { 0,"lhau",0,T_DD,43,0,0,0 },
  271.   { 0,"lhaux",0,T_X,31,0,0,(375<<1) },
  272.   { 0,"lhax",0,T_X,31,0,0,(343<<1) },
  273.   { 0,"lhbrx",0,T_X,31,0,0,(790<<1) },
  274.   { 0,"lhz",0,T_DD,40,0,0,0 },
  275.   { 0,"lhzu",0,T_DD,41,0,0,0 },
  276.   { 0,"lhzux",0,T_X,31,0,0,(311<<1) },
  277.   { 0,"lhzx",0,T_X,31,0,0,(279<<1) },
  278.   { 0,"lmw",0,T_DD,46,0,0,0 },
  279.   { 0,"lswi",0,T_X,31,0,0,(597<<1) },
  280.   { 0,"lswx",0,T_X,31,0,0,(533<<1) },
  281.   { 0,"lwa",F_64BIT,T_DS,58,0,0,2 },
  282.   { 0,"lwarx",0,T_X,31,0,0,(20<<1) },
  283.   { 0,"lwaux",F_64BIT,T_X,31,0,0,(373<<1) },
  284.   { 0,"lwax",F_64BIT,T_X,31,0,0,(341<<1) },
  285.   { 0,"lwbrx",0,T_X,31,0,0,(534<<1) },
  286.   { 0,"lwz",0,T_DD,32,0,0,0 },
  287.   { 0,"lwzu",0,T_DD,33,0,0,0 },
  288.   { 0,"lwzux",0,T_X,31,0,0,(55<<1) },
  289.   { 0,"lwzx",0,T_X,31,0,0,(23<<1) },
  290.   { 0,"mcrf",F_CRF_D|F_CRF_S|F_SUPP_B,T_X,19,0,0,(0<<1) },
  291.   { 0,"mcrfs",F_CRF_D|F_CRF_S|F_SUPP_B,T_X,63,0,0,(64<<1) },
  292.   { 0,"mcrxr",F_CRF_D|F_SUPP_A|F_SUPP_B,T_X,31,0,0,(512<<1) },
  293.   { 0,"mfcr",F_SUPP_A|F_SUPP_B,T_X,31,0,0,(19<<1) },
  294.   { 0,"mffs",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(583<<1)+0 },
  295.   { 0,"mffs.",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(583<<1)+1 },
  296.   { 0,"mfmsr",F_SUPP_A|F_SUPP_B|F_SUPER,T_X,31,0,0,(83<<1) },
  297.   { 0,"mfspr",0,T_XSPR,31,0,0,(339<<1) },
  298.   { 0,"mfsr",F_SUPP_B|F_SUPER,T_X,31,0,0,(595<<1) },
  299.   { 0,"mfsrin",F_SUPP_A|F_SUPER,T_X,31,0,0,(659<<1) },
  300.   { 0,"mftb",0,T_XSPR,31,0,0,(371<<1) },
  301.   { 0,"mtcrf",0,T_XCRM,31,0,0,(144<<1) },
  302.   { 0,"mtfsb0",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(70<<1)+0 },
  303.   { 0,"mtfsb0.",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(70<<1)+1 },
  304.   { 0,"mtfsb1",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(38<<1)+0 },
  305.   { 0,"mtfsb1.",F_SUPP_A|F_SUPP_B,T_X,63,0,0,(38<<1)+1 },
  306.   { 0,"mtfsf",0,T_XFL,63,0,0,(711<<1)+0 },
  307.   { 0,"mtfsf.",0,T_XFL,63,0,0,(711<<1)+1 },
  308.   { 0,"mtfsfi",0,T_IMM,63,0,0,(134<<1)+0 },
  309.   { 0,"mtfsfi.",0,T_IMM,63,0,0,(134<<1)+1 },
  310.   { 0,"mtmsr",F_SUPP_A|F_SUPP_B|F_SUPER,T_X,31,0,0,(146<<1) },
  311.   { 0,"mtspr",F_SWAP,T_XSPR,31,0,0,(467<<1) },
  312.   { 0,"mtsr",F_SWAP|F_SUPP_B|F_SUPER,T_X,31,0,0,(210<<1) },
  313.   { 0,"mtsrin",F_SUPP_A,T_X,31,0,0,(242<<1) },
  314.   { 0,"mulhd",F_64BIT,T_X,31,0,0,(73<<1)+0 },
  315.   { 0,"mulhd.",F_64BIT,T_X,31,0,0,(73<<1)+1 },
  316.   { 0,"mulhdu",F_64BIT,T_X,31,0,0,(9<<1)+0 },
  317.   { 0,"mulhdu.",F_64BIT,T_X,31,0,0,(9<<1)+1 },
  318.   { 0,"mulhw",0,T_X,31,0,0,(75<<1)+0 },
  319.   { 0,"mulhw.",0,T_X,31,0,0,(75<<1)+1 },
  320.   { 0,"mulhwu",0,T_X,31,0,0,(11<<1)+0 },
  321.   { 0,"mulhwu.",0,T_X,31,0,0,(11<<1)+1 },
  322.   { 0,"mulld",F_64BIT,T_X,31,0,0,(0<<10)+(233<<1)+0 },
  323.   { 0,"mulld.",F_64BIT,T_X,31,0,0,(0<<10)+(233<<1)+1 },
  324.   { 0,"mulldo",F_64BIT,T_X,31,0,0,(1<<10)+(233<<1)+0 },
  325.   { 0,"mulldo.",F_64BIT,T_X,31,0,0,(1<<10)+(233<<1)+1 },
  326.   { 0,"mulli",F_SIGNED,T_DI,7,0,0,0 },
  327.   { 0,"mullw",0,T_X,31,0,0,(0<<10)+(235<<1)+0 },
  328.   { 0,"mullw.",0,T_X,31,0,0,(0<<10)+(235<<1)+1 },
  329.   { 0,"mullwo",0,T_X,31,0,0,(1<<10)+(235<<1)+0 },
  330.   { 0,"mullwo.",0,T_X,31,0,0,(1<<10)+(235<<1)+1 },
  331.   { 0,"nand",F_SWAP,T_X,31,0,0,(476<<1)+0 },
  332.   { 0,"nand.",F_SWAP,T_X,31,0,0,(476<<1)+1 },
  333.   { 0,"neg",F_SUPP_B,T_X,31,0,0,(0<<10)+(104<<1)+0 },
  334.   { 0,"neg.",F_SUPP_B,T_X,31,0,0,(0<<10)+(104<<1)+1 },
  335.   { 0,"nego",F_SUPP_B,T_X,31,0,0,(1<<10)+(104<<1)+0 },
  336.   { 0,"nego.",F_SUPP_B,T_X,31,0,0,(1<<10)+(104<<1)+1 },
  337.   { 0,"nor",F_SWAP,T_X,31,0,0,(124<<1)+0 },
  338.   { 0,"nor.",F_SWAP,T_X,31,0,0,(124<<1)+1 },
  339.   { 0,"or",F_SWAP,T_X,31,0,0,(444<<1)+0 },
  340.   { 0,"or.",F_SWAP,T_X,31,0,0,(444<<1)+1 },
  341.   { 0,"orc",F_SWAP,T_X,31,0,0,(412<<1)+0 },
  342.   { 0,"orc.",F_SWAP,T_X,31,0,0,(412<<1)+1 },
  343.   { 0,"ori",F_SWAP,T_DI,24,0,0,0 },
  344.   { 0,"oris",F_SWAP,T_DI,25,0,0,0 },
  345.   { 0,"rfi",F_SUPP_D|F_SUPP_A|F_SUPP_B|F_SUPER,T_X,19,0,0,(50<<1) },
  346.   { 0,"rldcl",F_SWAP|F_64BIT,T_A,30,0,0,(8<<1)+0 },
  347.   { 0,"rldcl.",F_SWAP|F_64BIT,T_A,30,0,0,(8<<1)+1 },
  348.   { 0,"rldcr",F_SWAP|F_64BIT,T_A,30,0,0,(9<<1)+0 },
  349.   { 0,"rldcr.",F_SWAP|F_64BIT,T_A,30,0,0,(9<<1)+1 },
  350.   { 0,"rldic",F_64BIT,T_MD,30,0,0,(2<<2)+0 },
  351.   { 0,"rldic.",F_64BIT,T_MD,30,0,0,(2<<2)+1 },
  352.   { 0,"rldicl",F_64BIT,T_MD,30,0,0,(0<<2)+0 },
  353.   { 0,"rldicl.",F_64BIT,T_MD,30,0,0,(0<<2)+1 },
  354.   { 0,"rldicr",F_64BIT,T_MD,30,0,0,(1<<2)+0 },
  355.   { 0,"rldicr.",F_64BIT,T_MD,30,0,0,(1<<2)+1 },
  356.   { 0,"rldimi",F_64BIT,T_MD,30,0,0,(3<<2)+0 },
  357.   { 0,"rldimi.",F_64BIT,T_MD,30,0,0,(3<<2)+1 },
  358.   { 0,"rlwimi",0,T_M,20,0,0,0 },
  359.   { 0,"rlwimi.",0,T_M,20,0,0,1 },
  360.   { 0,"rlwinm",0,T_M,21,0,0,0 },
  361.   { 0,"rlwinm.",0,T_M,21,0,0,1 },
  362.   { 0,"rlwnm",0,T_M,23,0,0,0 },
  363.   { 0,"rlwnm.",0,T_M,23,0,0,1 },
  364.   { 0,"sc",F_SUPP_D|F_SUPP_A|F_SUPP_B,T_X,17,0,0,2 },
  365.   { 0,"slbia",F_SUPP_D|F_SUPP_A|F_SUPP_B|F_SUPER|F_64BIT|F_OPTIONAL,
  366.     T_X,31,0,0,(498<<1) },
  367.   { 0,"slbie",F_SUPP_D|F_SUPP_A|F_SUPER|F_64BIT|F_OPTIONAL,
  368.     T_X,31,0,0,(434<<1) },
  369.   { 0,"sld",F_SWAP|F_64BIT,T_X,31,0,0,(27<<1)+0 },
  370.   { 0,"sld.",F_SWAP|F_64BIT,T_X,31,0,0,(27<<1)+1 },
  371.   { 0,"slw",F_SWAP,T_X,31,0,0,(24<<1)+0 },
  372.   { 0,"slw.",F_SWAP,T_X,31,0,0,(24<<1)+1 },
  373.   { 0,"srad",F_SWAP|F_64BIT,T_X,31,0,0,(794<<1)+0 },
  374.   { 0,"srad.",F_SWAP|F_64BIT,T_X,31,0,0,(794<<1)+1 },
  375.   { 0,"sradi",F_64BIT,T_XS,31,0,0,(413<<2)+0 },
  376.   { 0,"sradi.",F_64BIT,T_XS,31,0,0,(413<<2)+1 },
  377.   { 0,"sraw",F_SWAP,T_X,31,0,0,(792<<1)+0 },
  378.   { 0,"sraw.",F_SWAP,T_X,31,0,0,(792<<1)+1 },
  379.   { 0,"srawi",F_SWAP,T_X,31,0,0,(824<<1)+0 },
  380.   { 0,"srawi.",F_SWAP,T_X,31,0,0,(824<<1)+1 },
  381.   { 0,"srd",F_SWAP|F_64BIT,T_X,31,0,0,(539<<1)+0 },
  382.   { 0,"srd.",F_SWAP|F_64BIT,T_X,31,0,0,(539<<1)+1 },
  383.   { 0,"srw",F_SWAP,T_X,31,0,0,(536<<1)+0 },
  384.   { 0,"srw.",F_SWAP,T_X,31,0,0,(536<<1)+1 },
  385.   { 0,"stb",0,T_DD,38,0,0,0 },
  386.   { 0,"stbu",0,T_DD,39,0,0,0 },
  387.   { 0,"stbux",0,T_X,31,0,0,(247<<1) },
  388.   { 0,"stbx",0,T_X,31,0,0,(215<<1) },
  389.   { 0,"std",F_64BIT,T_DS,62,0,0,0 },
  390.   { 0,"stdcx.",F_64BIT,T_X,31,0,0,(214<<1)+1 },
  391.   { 0,"stdu",F_64BIT,T_DS,62,0,0,1 },
  392.   { 0,"stdux",F_64BIT,T_X,31,0,0,(181<<1) },
  393.   { 0,"stdx",F_64BIT,T_X,31,0,0,(149<<1) },
  394.   { 0,"stfd",0,T_DD,54,0,0,0 },
  395.   { 0,"stfdu",0,T_DD,55,0,0,0 },
  396.   { 0,"stfdux",0,T_X,31,0,0,(759<<1) },
  397.   { 0,"stfdx",0,T_X,31,0,0,(727<<1) },
  398.   { 0,"stfiwx",F_OPTIONAL,T_X,31,0,0,(983<<1) },
  399.   { 0,"stfs",0,T_DD,52,0,0,0 },
  400.   { 0,"stfsu",0,T_DD,53,0,0,0 },
  401.   { 0,"stfsux",0,T_X,31,0,0,(695<<1) },
  402.   { 0,"stfsx",0,T_X,31,0,0,(663<<1) },
  403.   { 0,"sth",0,T_DD,44,0,0,0 },
  404.   { 0,"sthbrx",0,T_X,31,0,0,(918<<1) },
  405.   { 0,"sthu",0,T_DD,45,0,0,0 },
  406.   { 0,"sthux",0,T_X,31,0,0,(439<<1) },
  407.   { 0,"sthx",0,T_X,31,0,0,(407<<1) },
  408.   { 0,"stmw",0,T_DD,47,0,0,0 },
  409.   { 0,"stswi",0,T_X,31,0,0,(725<<1) },
  410.   { 0,"stswx",0,T_X,31,0,0,(661<<1) },
  411.   { 0,"stw",0,T_DD,36,0,0,0 },
  412.   { 0,"stwbrx",0,T_X,31,0,0,(662<<1) },
  413.   { 0,"stwcx.",0,T_X,31,0,0,(150<<1)+1 },
  414.   { 0,"stwu",0,T_DD,37,0,0,0 },
  415.   { 0,"stwux",0,T_X,31,0,0,(183<<1) },
  416.   { 0,"stwx",0,T_X,31,0,0,(151<<1) },
  417.   { 0,"subf",0,T_X,31,0,0,(0<<10)+(40<<1)+0 },
  418.   { 0,"subf.",0,T_X,31,0,0,(0<<10)+(40<<1)+1 },
  419.   { 0,"subfo",0,T_X,31,0,0,(1<<10)+(40<<1)+0 },
  420.   { 0,"subfo.",0,T_X,31,0,0,(1<<10)+(40<<1)+1 },
  421.   { 0,"subfc",0,T_X,31,0,0,(0<<10)+(8<<1)+0 },
  422.   { 0,"subfc.",0,T_X,31,0,0,(0<<10)+(8<<1)+1 },
  423.   { 0,"subfco",0,T_X,31,0,0,(1<<10)+(8<<1)+0 },
  424.   { 0,"subfco.",0,T_X,31,0,0,(1<<10)+(8<<1)+1 },
  425.   { 0,"subfe",0,T_X,31,0,0,(0<<10)+(136<<1)+0 },
  426.   { 0,"subfe.",0,T_X,31,0,0,(0<<10)+(136<<1)+1 },
  427.   { 0,"subfeo",0,T_X,31,0,0,(1<<10)+(136<<1)+0 },
  428.   { 0,"subfeo.",0,T_X,31,0,0,(1<<10)+(136<<1)+1 },
  429.   { 0,"subfic",F_SIGNED,T_DI,8,0,0,0 },
  430.   { 0,"subfme",F_SUPP_B,T_X,31,0,0,(0<<10)+(232<<1)+0 },
  431.   { 0,"subfme.",F_SUPP_B,T_X,31,0,0,(0<<10)+(232<<1)+1 },
  432.   { 0,"subfmeo",F_SUPP_B,T_X,31,0,0,(1<<10)+(232<<1)+0 },
  433.   { 0,"subfmeo.",F_SUPP_B,T_X,31,0,0,(1<<10)+(232<<1)+1 },
  434.   { 0,"subfze",F_SUPP_B,T_X,31,0,0,(0<<10)+(200<<1)+0 },
  435.   { 0,"subfze.",F_SUPP_B,T_X,31,0,0,(0<<10)+(200<<1)+1 },
  436.   { 0,"subfzeo",F_SUPP_B,T_X,31,0,0,(1<<10)+(200<<1)+0 },
  437.   { 0,"subfzeo.",F_SUPP_B,T_X,31,0,0,(1<<10)+(200<<1)+1 },
  438.   { 0,"sync",F_SUPP_D|F_SUPP_A|F_SUPP_B,T_X,31,0,0,(598<<1) },
  439.   { 0,"td",F_64BIT,T_X,31,0,0,(68<<1) },
  440.   { 0,"tdi",F_SIGNED|F_64BIT,T_DI,2,0,0,0 },
  441.   { 0,"tlbia",F_SUPP_D|F_SUPP_A|F_SUPP_B|F_SUPER|F_OPTIONAL,
  442.     T_X,31,0,0,(370<<1) },
  443.   { 0,"tlbie",F_SUPP_D|F_SUPP_A|F_SUPER|F_OPTIONAL,T_X,31,0,0,(306<<1) },
  444.   { 0,"tlsync",F_SUPP_D|F_SUPP_A|F_SUPP_B|F_SUPER|F_OPTIONAL,
  445.     T_X,31,0,0,(566<<1) },
  446.   { 0,"tw",0,T_X,31,0,0,(4<<1) },
  447.   { 0,"twi",F_SIGNED,T_DI,3,0,0,0 },
  448.   { 0,"xor",F_SWAP,T_X,31,0,0,(316<<1)+0 },
  449.   { 0,"xor.",F_SWAP,T_X,31,0,0,(316<<1)+1 },
  450.   { 0,"xori",F_SWAP,T_DI,26,0,0,0 },
  451.   { 0,"xoris",F_SWAP,T_DI,27,0,0,0 },
  452.  
  453.   /* extended mnemonics, rest is implemented as predefined macros */
  454.   { 0,"la",F_EXTENDED,T_DD,14,0,0,0 },
  455.   { 0,0 } /* end mark */
  456. };
  457.  
  458.  
  459.  
  460. void instr(struct GlobalVars *gv,struct ParsedLine *pl)
  461. {
  462.   struct CPUInstr *ins=(struct CPUInstr *)pl->opcode;
  463.   char *op=pl->operand;
  464.   uint32 d=ins->fieldD,a=ins->fieldA;
  465.   uint32 b=0,c=0,x=0;
  466.   uint32 oc=ins->opcd<<26;
  467.   uint32 xo=ins->xo;
  468.   uint16 flags=ins->flags;
  469.   char *oldop=op;
  470.   struct Expression exp;
  471.   bool signchk=TRUE;
  472.  
  473.   if (flags & F_64BIT)
  474.     if (!gv->sixtyfourmode)
  475.       error(37,ins->name);  /* warning: 64-bit instruction */
  476.   if (flags & F_OPTIONAL)
  477.     if (!gv->optinstrmode)
  478.       error(38,ins->name);  /* warning: optional instruction */
  479.   if (flags & F_SUPER)
  480.     if (!gv->supermode)
  481.       error(39,ins->name);  /* warning: supervisor-level instruction */
  482.   gv->signedexp = flags&F_SIGNED ? TRUE:FALSE;
  483.  
  484.   switch (ins->type) {
  485.   
  486.     case T_I:  /* Bx */
  487.       op = eval_expression(gv,&exp,op);
  488.       if (exp.type < SYM_RELOC)
  489.         switch (exp.type) {
  490.           case SYM_UNDEF:
  491.             error(19);  /* undefined symbol */
  492.             break;
  493.           case SYM_ABS:
  494.             error(32);  /* Reloc symbol required */
  495.             break;
  496.         }
  497.       if (flags & F_SIGNED) {  /* relative branch */
  498.         exp.reloctype = R_PPC_REL24;
  499.         switch (exp.type) {
  500.           case SYM_RELOC:
  501.             if (exp.symbol->relsect == gv->csect)
  502.               x = exp.value - gv->csect->pc;  /* branch distance */
  503.             else {
  504.               error(33);  /* branch destination is not in current section */
  505.               x = makereloc(gv,&exp);
  506.             }
  507.             break;
  508.           case SYM_EXTERN:
  509.             x = makexref(gv,&exp,3);
  510.             break;
  511.         }
  512.         checkrange(x,3,TRUE);
  513.       }
  514.       else {  /* absolute branch */
  515.         exp.reloctype = R_PPC_ADDR24;
  516.         switch (exp.type) {
  517.           case SYM_RELOC:
  518.             x = makereloc(gv,&exp);
  519.             break;
  520.           case SYM_EXTERN:
  521.             x = makexref(gv,&exp,3);
  522.             break;
  523.         }
  524.         checkrange(x,3,FALSE);        
  525.       }
  526.       oc |= (x&0x3fffffc)|xo;
  527.       break;
  528.  
  529.     case T_B:  /* BCx */
  530.       op = getintexp(gv,op,&d);  /* BO, branch operand */
  531.       if (!(op = check_comma(op)))
  532.         break;
  533.       op = getintexp(gv,op,&a);  /* BI, branch condition index */
  534.       if (!(op = check_comma(op)))
  535.         break;
  536.       oldop = op;
  537.       op = eval_expression(gv,&exp,op);
  538.       if (exp.type < SYM_RELOC)
  539.         switch (exp.type) {
  540.           case SYM_UNDEF:
  541.             error(19);  /* undefined symbol */
  542.             break;
  543.           case SYM_ABS:
  544.             error(32);  /* Reloc symbol required */
  545.             break;
  546.         }
  547.       if (flags & F_SIGNED) {  /* relative branch */
  548.         exp.reloctype = R_PPC_REL14;
  549.         switch (exp.type) {
  550.           case SYM_RELOC:
  551.             if (exp.symbol->relsect == gv->csect) {
  552.               x = exp.value - gv->csect->pc;  /* branch distance */
  553.               if (gv->opt & OPT_FAR_BRANCH)
  554.                 opt_far_branch(gv,pl,&d,&a,(int32 *)&x,oldop);
  555.             }
  556.             else {
  557.               error(33);  /* branch destination is not in current section */
  558.               x = makereloc(gv,&exp);
  559.             }
  560.             break;
  561.           case SYM_EXTERN:
  562.             x = makexref(gv,&exp,2);
  563.             break;
  564.         }
  565.         checkrange(x,2,TRUE);
  566.       }
  567.       else {  /* absolute branch */
  568.         exp.reloctype = R_PPC_ADDR14;
  569.         switch (exp.type) {
  570.           case SYM_RELOC:
  571.             x = makereloc(gv,&exp);
  572.             break;
  573.           case SYM_EXTERN:
  574.             x = makexref(gv,&exp,2);
  575.             break;
  576.         }
  577.         checkrange(x,2,FALSE);        
  578.       }
  579.       if (flags & F_SIGNED) {
  580.         if ((int32)x >= 0)
  581.           d &= ~1;
  582.         else
  583.           d |= 1;
  584.       }
  585.       else {
  586.         if (x < gv->csect->pc && exp.symbol->relsect == gv->csect)
  587.           d |= 1;
  588.         else
  589.           d &= ~1;
  590.       }
  591.       if (pl->branch_hint > 0)  /* + */
  592.         d ^= 1;
  593.       x &= 0xfffc;
  594.       if (gv->output == OFMT_EHF)  /* hack to allow correct EHF relocation */
  595.         x += 2;
  596.       if (d>31 || a>31)
  597.         error(34);  /* Branch operand out of range */
  598.       else
  599.         oc |= (d<<21)|(a<<16)|x|xo;
  600.       break;
  601.  
  602.     case T_XLB:  /* BCLRx,BCCTRx */
  603.       op = getintexp(gv,op,&d);  /* BO, branch operand */
  604.       if (!(op = check_comma(op)))
  605.         break;
  606.       op = getintexp(gv,op,&a);  /* BI, branch condition index */
  607.       if (pl->branch_hint > 0)
  608.         d |= 1;
  609.       else if (pl->branch_hint < 0)
  610.         d &= ~1;
  611.       if (d>31 || a>31)
  612.         error(34);  /* Branch operand out of range */
  613.       else
  614.         oc |= (d<<21)|(a<<16)|xo;
  615.       break;
  616.  
  617.     case T_CMP:  /* CMP, CMPI, CMPL, CMPLI */
  618.       if (count_operands(gv,op) > 3) {  /* CR-field specified? */
  619.         op = getintexp(gv,op,&d);
  620.         if (!(op = check_comma(op)))
  621.           break;
  622.       }
  623.       op = getintexp(gv,op,&c);  /* L = word or double word */
  624.       if (!(op = check_comma(op)))
  625.         break;
  626.       op = getintexp(gv,op,&a);
  627.       if (!(op = check_comma(op)))
  628.         break;
  629.       if (flags & F_SUPP_B) {  /* immediate comparison */
  630.         op = getexp(gv,op,&x,2);
  631.         checkrange(x,2,flags&F_SIGNED);
  632.       }
  633.       else  /* register comparison */
  634.         op = getintexp(gv,op,&b);
  635.       if (d>7)
  636.         error(35);  /* CR-specifier out of range */
  637.       else if (c>1)
  638.         error(36,"L");  /* Operand field out of range */
  639.       else if (a>31 || b>31)
  640.         error(31);  /* register operand out of range */
  641.       else if (flags & F_SUPP_B)
  642.         oc |= (d<<23)|(c<<21)|(a<<16)|(x&0xffff);
  643.       else
  644.         oc |= (d<<23)|(c<<21)|(a<<16)|(b<<11)|xo;
  645.       break;
  646.  
  647.     case T_DI:  /* ADDI,ANDI,ORI */
  648.       op = getintexp(gv,op,&d);
  649.       if (!(op = check_comma(op)))
  650.         break;
  651.       op = getintexp(gv,op,&a);
  652.       if (!(op = check_comma(op)))
  653.         break;
  654.       op = getexp(gv,op,&x,2);
  655.       if (flags & F_SWAP)
  656.         swapops(&d,&a);
  657.       checkrange(x,2,flags&F_SIGNED);
  658.       if (d>31 || a>31)
  659.         error(31);  /* register operand out of range */
  660.       else
  661.         oc |= (d<<21)|(a<<16)|(x&0xffff);
  662.       break;
  663.  
  664.     case T_X:  /* ADDx, ANDx, DIVx, FMRx, .. */
  665.       if (!(flags & F_SUPP_D))
  666.         op = getintexp(gv,op,&d);
  667.       if (!(flags & F_SUPP_A)) {
  668.         if (op != oldop)
  669.           if (!(op = check_comma(op)))
  670.             break;
  671.         op = getintexp(gv,op,&a);
  672.       }
  673.       if (!(flags & F_SUPP_B)) {
  674.         if (op != oldop)
  675.           if (!(op = check_comma(op)))
  676.             break;
  677.         op = getintexp(gv,op,&b);
  678.       }
  679.       if (flags & F_CRF_D)
  680.         d <<= 2;
  681.       if (flags & F_CRF_S)
  682.         a <<= 2;
  683.       if (flags & F_SWAP)
  684.         swapops(&d,&a);
  685.       if (d>31 || a>31 || b>31)
  686.         error(31);
  687.       else
  688.         oc |= (d<<21)|(a<<16)|(b<<11)|xo;
  689.       break;
  690.  
  691.     case T_A:  /* FADDx, FSUBx, FMULx, FDIVx, .. */
  692.       if (!(flags & F_SUPP_D))
  693.         op = getintexp(gv,op,&d);
  694.       if (!(flags & F_SUPP_A)) {
  695.         if (op != oldop)
  696.           if (!(op = check_comma(op)))
  697.             break;
  698.         op = getintexp(gv,op,&a);
  699.       }
  700.       if (!(flags & F_SUPP_C)) {
  701.         if (op != oldop)
  702.           if (!(op = check_comma(op)))
  703.             break;
  704.         op = getintexp(gv,op,&c);
  705.       }
  706.       if (!(flags & F_SUPP_B)) {
  707.         if (op != oldop)
  708.           if (!(op = check_comma(op)))
  709.             break;
  710.         op = getintexp(gv,op,&b);
  711.       }
  712.       if (flags & F_SWAP) {  /* rldcl/rldcr rA,rS,rB,mb */
  713.         swapops(&d,&a);
  714.         swapops(&c,&b);
  715.       }
  716.       if (d>31 || a>31 || b>31 || c>31)
  717.         error(31);
  718.       else
  719.         oc |= (d<<21)|(a<<16)|(b<<11)|(c<<6)|xo;
  720.       break;
  721.  
  722.     case T_DD:  /* LBZ, LHA, LZWU, STBU, STW, .. */
  723.       op = getintexp(gv,op,&d);
  724.       if (!(op = check_comma(op)))
  725.         break;
  726.       if (chk_regindir(op)) {   /* rD,(rA) -> rD,0(rA) */
  727.         exp.value = 0;
  728.         exp.type = SYM_ABS;
  729.       }
  730.       else
  731.         op = eval_expression(gv,&exp,op);
  732.       if (*op++ == '(') {
  733.         op = getintexp(gv,op,&a);
  734.         if (*op++ != ')') {
  735.           error(40);  /* (rA) expected, after index expression */
  736.           op = NULL;
  737.           break;
  738.         }
  739.         if (exp.type != SYM_UNDEF) {
  740.           switch (exp.type) {
  741.             case SYM_RELOC:
  742.               if (exp.reloctype == R_PPC_ADDR16_LO) {  /* sym@l */
  743.                 x = makereloc(gv,&exp);
  744.                 signchk = FALSE;
  745.                 break;
  746.               }
  747.               else if (exp.symbol->relsect == gv->tocsect) {
  748.                 if ((int)a == gv->rtoc) {  /* valid ref. to rtoc symbol */
  749.                   exp.reloctype = R_PPC_TOC16;
  750.                   x = makereloc(gv,&exp);
  751.                   break;
  752.                 }
  753.               }
  754.               error(46);  /* symbol is not part of a base-relative section */
  755.               break;
  756.             case SYM_EXTERN:  /* reference to external symbol */
  757.               if (exp.reloctype != R_PPC_ADDR16_LO)
  758.                 exp.reloctype = R_PPC_ADDR16;
  759.               else if ((int)a == gv->rtoc)   /* ext. symbol via rtoc - */
  760.                 exp.reloctype = R_PPC_TOC16; /* might be a TOC16 ref.  */
  761.               x = makexref(gv,&exp,2);
  762.               break;
  763.             default:  /* SYM_ABS */
  764.               x = exp.value;
  765.               break;
  766.           }
  767.         }
  768.         else
  769.           error(19);  /* undefined symbol */
  770.       }
  771.       else {  /* rD,v -> rD,v_off(rtoc) */
  772.         if (exp.type != SYM_UNDEF) {
  773.           switch (exp.type) {
  774.             case SYM_RELOC:
  775.               if (exp.symbol->relsect == gv->tocsect) {
  776.                 a = gv->rtoc;
  777.                 exp.reloctype = R_PPC_TOC16;
  778.                 x = makereloc(gv,&exp);
  779.                 break;
  780.               }
  781.               error(46);
  782.               break;
  783.             case SYM_EXTERN:  /* we assume that this is a TOC16 reference */
  784.               a = gv->rtoc;
  785.               exp.reloctype = R_PPC_TOC16;
  786.               x = makexref(gv,&exp,2);
  787.               break;
  788.             default:
  789.               error(46);
  790.               break;
  791.           }
  792.         }
  793.         else
  794.           error(19);
  795.       }
  796.       checkrange(x,2,signchk);
  797.       if (d>31 || a>31)
  798.         error(31);  /* register operand out of range */
  799.       else
  800.         oc |= (d<<21)|(a<<16)|(x&0xffff);
  801.       break;
  802.  
  803.     case T_DS:  /* LD, LDU, LWA, STD , .. */
  804.       op = getintexp(gv,op,&d);
  805.       if (!(op = check_comma(op)))
  806.         break;
  807.       if (chk_regindir(op)) {   /* rD,(rA) -> rD,0(rA) */
  808.         exp.value = 0;
  809.         exp.type = SYM_ABS;
  810.       }
  811.       else
  812.         op = eval_expression(gv,&exp,op);
  813.       if (*op++ == '(') {
  814.         op = getintexp(gv,op,&a);
  815.         if (*op++ != ')') {
  816.           error(40);  /* (rA) expected, after index expression */
  817.           op = NULL;
  818.           break;
  819.         }
  820.         if (exp.type != SYM_UNDEF) {
  821.           switch (exp.type) {
  822.             case SYM_RELOC:
  823.               if (exp.reloctype == R_PPC_ADDR16_LO) {  /* sym@l */
  824.                 x = makereloc(gv,&exp);
  825.                 signchk = FALSE;
  826.                 break;
  827.               }
  828.               else if (exp.symbol->relsect == gv->tocsect) {
  829.                 if ((int)a == gv->rtoc) {  /* valid ref. to rtoc symbol */
  830.                   exp.reloctype = R_PPC_TOC16;
  831.                   x = makereloc(gv,&exp);
  832.                   break;
  833.                 }
  834.               }
  835.               error(46);  /* symbol is not part of a base-relative section */
  836.               break;
  837.             case SYM_EXTERN:  /* reference to external symbol */
  838.               if (exp.reloctype != R_PPC_ADDR16_LO)
  839.                 exp.reloctype = R_PPC_ADDR16;
  840.               else if ((int)a == gv->rtoc)   /* ext. symbol via rtoc - */
  841.                 exp.reloctype = R_PPC_TOC16; /* might be a TOC16 ref.  */
  842.               x = makexref(gv,&exp,2);
  843.               break;
  844.             default:  /* SYM_ABS */
  845.               x = exp.value;
  846.               break;
  847.           }
  848.         }
  849.         else
  850.           error(19);  /* undefined symbol */
  851.       }
  852.       else {  /* rD,v -> rD,v_off(rtoc) */
  853.         if (exp.type != SYM_UNDEF) {
  854.           switch (exp.type) {
  855.             case SYM_RELOC:
  856.               if (exp.symbol->relsect == gv->tocsect) {
  857.                 a = gv->rtoc;
  858.                 exp.reloctype = R_PPC_TOC16;
  859.                 x = makereloc(gv,&exp);
  860.                 break;
  861.               }
  862.               error(46);
  863.               break;
  864.             case SYM_EXTERN:  /* we assume that this is a TOC16 reference */
  865.               a = gv->rtoc;
  866.               exp.reloctype = R_PPC_TOC16;
  867.               x = makexref(gv,&exp,2);
  868.               break;
  869.             default:
  870.               error(46);
  871.               break;
  872.           }
  873.         }
  874.         else
  875.           error(19);
  876.       }
  877.       checkrange(x,2,signchk);
  878.       if (x & 3)
  879.         error(41);  /* expression must be dividable by four */
  880.       else if (d>31 || a>31)
  881.         error(31);  /* register operand out of range */
  882.       else
  883.         oc |= (d<<21)|(a<<16)|(x&0xfffc)|xo;
  884.       break;
  885.  
  886.     case T_XSPR:  /* MFSPR, MTSPR */
  887.       op = getintexp(gv,op,&d);
  888.       if (!(op = check_comma(op)))
  889.         break;
  890.       op = getintexp(gv,op,&a);
  891.       if (flags & F_SWAP)
  892.         swapops(&d,&a);
  893.       if (d>31 || a>0x3ff)
  894.         error(31);
  895.       else
  896.         oc |= (d<<21)|((a&0x1f)<<16)|((a&0x3e0)<<6)|xo;
  897.       break;
  898.  
  899.     case T_XCRM:  /* MFCRF */
  900.       op = getintexp(gv,op,&x);
  901.       if (!(op = check_comma(op)))
  902.         break;
  903.       op = getintexp(gv,op,&d);
  904.       if (x > 0xff)
  905.         error(42);  /* invalid register field mask */
  906.       else if (a>31)
  907.         error(31);
  908.       else
  909.         oc |= (d<<21)|(x<<12)|xo;
  910.       break;
  911.  
  912.     case T_XFL:  /* MTFSF */
  913.       op = getintexp(gv,op,&x);
  914.       if (!(op = check_comma(op)))
  915.         break;
  916.       op = getintexp(gv,op,&b);
  917.       if (x > 0xff)
  918.         error(42);  /* invalid register field mask */
  919.       else if (b>31)
  920.         error(31);
  921.       else
  922.         oc |= (x<<17)|(b<<11)|xo;
  923.       break;
  924.  
  925.     case T_IMM:  /* MTFSFI */
  926.       op = getintexp(gv,op,&d);
  927.       if (!(op = check_comma(op)))
  928.         break;
  929.       op = getintexp(gv,op,&b);
  930.       if (b>15)
  931.         error(36,"IMM");  /* operand field out of range */
  932.       else if (d>7)
  933.         error(31);
  934.       else
  935.         oc |= (d<<23)|(b<<12)|xo;
  936.       break;
  937.  
  938.     case T_MD:  /* RLDIC, .. */
  939.       op = getintexp(gv,op,&a);
  940.       if (!(op = check_comma(op)))
  941.         break;
  942.       op = getintexp(gv,op,&d);
  943.       if (!(op = check_comma(op)))
  944.         break;
  945.       op = getintexp(gv,op,&b);
  946.       if (!(op = check_comma(op)))
  947.         break;
  948.       op = getintexp(gv,op,&c);
  949.       if (b>63)
  950.         error(36,"SH");  /* operand field out of range */
  951.       else if (c>31)
  952.         error(36,"MB/ME");
  953.       else if (d>31 || a>31)
  954.         error(31);
  955.       else
  956.         oc |= (d<<21)|(a<<16)|((b&0x1f)<<11)|(c<<6)|xo|((b&0x20)>>4);
  957.       break;
  958.  
  959.     case T_M:  /* RLWINM, RLWNM, RLWIMI, .. */
  960.       op = getintexp(gv,op,&a);
  961.       if (!(op = check_comma(op)))
  962.         break;
  963.       op = getintexp(gv,op,&d);
  964.       if (!(op = check_comma(op)))
  965.         break;
  966.       op = getintexp(gv,op,&b);
  967.       if (!(op = check_comma(op)))
  968.         break;
  969.       op = getintexp(gv,op,&c);
  970.       if (!(op = check_comma(op)))
  971.         break;
  972.       op = getintexp(gv,op,&x);
  973.       if (b>31)
  974.         error(36,"SH/rB");  /* operand field out of range */
  975.       else if (c>31)
  976.         error(36,"MB");
  977.       else if (c>31)
  978.         error(36,"ME");
  979.       else if (d>31 || a>31)
  980.         error(31);
  981.       else
  982.         oc |= (d<<21)|(a<<16)|(b<<11)|(c<<6)|(x<<1)|xo;
  983.       break;
  984.  
  985.     case T_XS:  /* SRADIx */
  986.       op = getintexp(gv,op,&a);
  987.       if (!(op = check_comma(op)))
  988.         break;
  989.       op = getintexp(gv,op,&d);
  990.       if (!(op = check_comma(op)))
  991.         break;
  992.       op = getintexp(gv,op,&b);
  993.       if (b>63)
  994.         error(36,"SH");  /* operand field out of range */
  995.       else if (d>31 || a>31)
  996.         error(31);
  997.       else
  998.         oc |= (d<<21)|(a<<16)|((b&0x1f)<<11)|xo|((b&0x20)>>4);
  999.       break;
  1000.   }
  1001.  
  1002.   store_word(gv,oc);
  1003.   if (op)
  1004.     checkEOL(op);
  1005. }
  1006.  
  1007.  
  1008. static void opt_far_branch(struct GlobalVars *gv,struct ParsedLine *pl,
  1009.                            uint32 *bo,uint32 *bi,int32 *bd,char *lab)
  1010. /* If branch destination is out of range, convert into a */
  1011. /* B!cc $+8 / B combination. */
  1012. {
  1013.   if (*bd>0x7fff || *bd<-0x8000) {
  1014.     struct ParsedLine *newpl = alloczero(sizeof(struct ParsedLine));
  1015.     char buf[STRBUFSIZE];
  1016.  
  1017.     move_symbols(gv,(uint32)gv->csect->pc,4); /* space for new instruction */
  1018.     *bo ^= 8;  /* negate condition */
  1019.     *bd = 8;   /* branch displacement = "$+8" */
  1020.     newpl->type = OT_INSTRUCTION;
  1021.     newpl->flags = pl->flags;
  1022.     newpl->narg = pl->narg;
  1023.     newpl->lineptr = pl->lineptr;
  1024.     newpl->opcode = (void *)search_instr(gv,"b");
  1025.     newpl->operand = lab;
  1026.     newpl->next = pl->next;
  1027.     /* free(pl->operand); @@@@ ? */
  1028.     sprintf(buf,"%d,%d,$+8",(int)*bo,(int)*bi);
  1029.     pl->branch_hint = -(pl->branch_hint);
  1030.     pl->operand = allocstring(buf);
  1031.     pl->next = newpl;
  1032.   }
  1033. }
  1034.  
  1035.  
  1036. static void swapops(uint32 *a,uint32 *b)
  1037. {
  1038.   uint32 c = *a;
  1039.  
  1040.   *a = *b;
  1041.   *b = c;
  1042. }
  1043.  
  1044.  
  1045. static int count_operands(struct GlobalVars *gv,char *s)
  1046. {
  1047.   int n=0;
  1048.  
  1049.   if (*s!=0 && *s!='#')
  1050.     do {
  1051.       n++;
  1052.       s = skipexpression(gv,s);
  1053.     }
  1054.     while (*s++ == ',');
  1055.   return (n);
  1056. }
  1057.  
  1058.  
  1059. static bool chk_regindir(char *s)
  1060. /* "(...)\0" has a high probability to be a register-indirect */
  1061. /* addressing mode. */
  1062. {
  1063.   char c;
  1064.  
  1065.   if (*s++ == '(') {
  1066.     while (c = *s++) {
  1067.       if (c == '(')
  1068.         break;           /* "((..." will never be register-indirect */
  1069.       if (c == ')') {
  1070.         s = skipspaces(s);
  1071.         if (*s == '\0')  /* line ends directly after "(...)" ? */
  1072.           return (TRUE);
  1073.         else
  1074.           break;
  1075.       }
  1076.     }
  1077.   }
  1078.   return (FALSE);
  1079. }
  1080.  
  1081.  
  1082. static void move_symbols(struct GlobalVars *gv,uint32 so,int32 d)
  1083. /* All relocatable symbols of current section with a greater */
  1084. /* section-offset than 'so' are moved by delta 'd'. */
  1085. {
  1086.   struct AlignPoint *ap = gv->csect->current_align;
  1087.   long g,a;
  1088.   unsigned long off;
  1089.  
  1090.   move_aligned_symbols_offset(gv,ap,so,d);
  1091.   while (ap = ap->next) {
  1092.     g = ap->gap - d;
  1093.     a = ap->val;
  1094.     off = ap->offset + ap->gap;  /* current offset after alignment */
  1095.     ap->offset += d;             /* new align-point offset */
  1096.     if (g<0 || g>=a) {  /* need to move the alignment point? */
  1097.       g = a - (ap->offset & (a-1));
  1098.       d = ap->offset + g - off;
  1099.       ap->gap = g;
  1100.       move_aligned_symbols_all(gv,ap,d);    
  1101.     }
  1102.     else {  /* delta is neutralized by alignment gap */
  1103.       ap->gap = g;
  1104.       break;
  1105.     }
  1106.   }
  1107.   gv->csect->data = NULL;  /* no further data is written to section */
  1108.   gv->anotherpass = TRUE;  /* this requires another pass :( */
  1109. }
  1110.  
  1111.  
  1112. static void move_aligned_symbols_offset(struct GlobalVars *gv,
  1113.                                         struct AlignPoint *ap,
  1114.                                         uint32 so,int32 d)
  1115. {
  1116.   struct Symbol *sym;
  1117.   struct Symbol **symtab = gv->symbols;
  1118.   int i;
  1119.  
  1120.   for (i=0; i<SYMHTABSIZE; i++) {
  1121.     sym = *symtab++;
  1122.     while (sym) {
  1123.       if (sym->type == SYM_RELOC)
  1124.         if (sym->alignpoint == ap)
  1125.           if (sym->value > so)
  1126.             sym->value += d;
  1127.       sym = sym->hash_chain;
  1128.     }
  1129.   }
  1130. }
  1131.  
  1132.  
  1133. static void move_aligned_symbols_all(struct GlobalVars *gv,
  1134.                                      struct AlignPoint *ap,int32 d)
  1135. {
  1136.   struct Symbol *sym;
  1137.   struct Symbol **symtab = gv->symbols;
  1138.   int i;
  1139.  
  1140.   for (i=0; i<SYMHTABSIZE; i++) {
  1141.     sym = *symtab++;
  1142.     while (sym) {
  1143.       if (sym->type==SYM_RELOC && sym->alignpoint==ap)
  1144.         sym->value += d;
  1145.       sym = sym->hash_chain;
  1146.     }
  1147.   }
  1148. }
  1149.  
  1150.  
  1151. char *check_comma(char *s)
  1152. {
  1153.   s = skipspaces(s);
  1154.   if (*s++ != ',') {
  1155.     error(27);  /* instruction has too few operands */
  1156.     return (NULL);
  1157.   }
  1158.   s = skipspaces(s);
  1159.   return (s);
  1160. }
  1161.  
  1162.  
  1163. void pcadd(struct GlobalVars *gv,unsigned long offset)
  1164. {
  1165.   gv->csect->pc += offset;
  1166. }
  1167.  
  1168.  
  1169. void store_byte(struct GlobalVars *gv,uint8 x)
  1170. {
  1171.   struct Section *sec = gv->csect;
  1172.   uint8 *d;
  1173.  
  1174.   if (d = (uint8 *)sec->data) {
  1175.     *d++ = x;
  1176.     sec->data = d;
  1177.   }
  1178.   sec->pc += 1;
  1179.   gv->lcsym->value += 1;
  1180. }
  1181.  
  1182.  
  1183. void store_half(struct GlobalVars *gv,uint16 x)
  1184. {
  1185.   struct Section *sec = gv->csect;
  1186.   uint16 *d;
  1187.  
  1188.   if (d = (uint16 *)sec->data) {
  1189.     *d++ = ECVH(x);
  1190.     sec->data = d;
  1191.   }
  1192.   sec->pc += 2;
  1193.   gv->lcsym->value += 2;
  1194. }
  1195.  
  1196.  
  1197. void store_word(struct GlobalVars *gv,uint32 x)
  1198. {
  1199.   struct Section *sec = gv->csect;
  1200.   uint32 *d;
  1201.  
  1202.   if (d = (uint32 *)sec->data) {
  1203.     *d++ = ECVW(x);
  1204.     sec->data = d;
  1205.   }
  1206.   sec->pc += 4;
  1207.   gv->lcsym->value += 4;
  1208. }
  1209.  
  1210.  
  1211. void store_float(struct GlobalVars *gv,double x)
  1212. {
  1213.   struct Section *sec = gv->csect;
  1214.   float *d;
  1215.  
  1216.   if (d = (float *)sec->data) {
  1217.     *d++ = (float)x;
  1218.     sec->data = d;
  1219.   }
  1220.   sec->pc += 4;
  1221.   gv->lcsym->value += 4;
  1222. }
  1223.  
  1224.  
  1225. void store_double(struct GlobalVars *gv,double x)
  1226. {
  1227.   struct Section *sec = gv->csect;
  1228.   double *d;
  1229.  
  1230.   if (d = (double *)sec->data) {
  1231.     *d++ = x;
  1232.     sec->data = d;
  1233.   }
  1234.   sec->pc += 8;
  1235.   gv->lcsym->value += 8;
  1236. }
  1237.  
  1238.  
  1239. void store_space(struct GlobalVars *gv,unsigned long n)
  1240. {
  1241.   struct Section *sec = gv->csect;
  1242.   uint8 *d;
  1243.  
  1244.   sec->pc += n;
  1245.   gv->lcsym->value += n;
  1246.   if (d = (uint8 *)sec->data) {
  1247.     while (n--)
  1248.       *d++ = 0;
  1249.     sec->data = d;
  1250.   }
  1251. }
  1252.