DLW-1e/das/pass2.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <stdlib.h>
   4 #include <ctype.h>
   5 #include <errno.h>
   6
   7 #include "pass2.h"
   8 #include "file.h"
   9 #include "opcode.h"
  10 #include "symbol_tbl.h"
  11 #include "error.h"
  12
  13 static char *get_opcode(char *line, unsigned long line_nr,
  14                         struct opcode **opcode)
  15 {
  16         char *endp, *p;
  17
  18         p = strchr(line, '\n');
  19         if (p)
  20                 *p = '\0';
  21
  22         endp = strchr(line, '\0');
  23
  24         p = strchr(line, ' ');
  25         if (p)
  26                 *p = '\0';
  27
  28         *opcode = opcode_lookup(line);
  29         if (!*opcode) {
  30                 error(line_nr, "instruction '%s' is not known", line);
  31                 return NULL;
  32         }
  33
  34         p = strchr(line, '\0');
  35
  36         if (p == endp && ((*opcode)->nr_operands > 0)) {
  37                 error(line_nr, "instruction requires operands");
  38                 return NULL;
  39         }
  40
  41         return ++p;
  42 }
  43
  44 static char *eat_immediate(oper_t *op_value, char *line, int line_nr)
  45 {
  46         int i;
  47         long ret;
  48         char c, *p;
  49
  50         for (i = 0; isdigit(line[i]); i++)
  51                 /* NOTHING */ ;
  52
  53         if (i == 0) {
  54                 error(line_nr, "no immediate in line");
  55                 return NULL;
  56         }
  57
  58         p = get_line_end(&line[i], strlen(&line[i]), line_nr);
  59
  60         c = *p;
  61         *p = '\0';
  62
  63         ret = strtol(line, NULL, 10);
  64         if (ret > 255) {
  65                 error(line_nr, "immediate value overflow");
  66                 return NULL;
  67         }
  68         if (ret < 0) {
  69                 error(line_nr, "negative immediate value not suported yet");
  70                 return NULL;
  71         }
  72
  73         *p = c;
  74
  75         *op_value = (oper_t) ret;
  76
  77         return p;
  78 }
  79
  80 static char *eat_register(oper_t *op_value, char *line, int line_nr)
  81 {
  82         size_t len;
  83
  84         len = strlen(line);
  85         if (len < 2)
  86                 goto out_err;
  87
  88         if (line[0] != 'r')
  89                 goto out_err;
  90
  91         *op_value = (oper_t) strtol(&line[1], NULL, 10);
  92         if (*op_value < 1 || *op_value > 4)
  93                 goto out_err;
  94
  95         *op_value -= 1;
  96         return get_line_end(&line[2], len, line_nr);
  97
  98 out_err:
  99         error(line_nr, "invalid register specified");
 100         return NULL;
 101 }
 102
 103 static char *eat_label(oper_t *op_value, char *line, int line_nr)
 104 {
 105         char c;
 106         int ret, i;
 107
 108         for (i = 0; isalpha(line[i]) || isdigit(line[i]); i++)
 109                 /* NOTHING */ ;
 110
 111         c = line[i];
 112         line[i] = '\0';
 113
 114         ret = symbol_tbl_lookup(line);
 115         if (ret < 0) {
 116                 error(line_nr, "undefined symbol %s", line);
 117                 return NULL;
 118         }
 119
 120         *op_value = (oper_t) ret;
 121         line[i] = c;
 122
 123         return get_line_end(&line[i], strlen(&line[i]), line_nr);
 124 }
 125
 126 static char *get_next_operand(char *line, struct operand *operand,
 127                               int line_nr)
 128 {
 129         char *p;
 130
 131         for (p = line; *p != '\0'; p++, line_nr++) {
 132                 switch (*p) {
 133                 case ASM_SPACE:
 134                 case ASM_OP_SEP:
 135                         break;
 136                 case ASM_COMMENT:
 137                         goto out;
 138                 case ASM_OP_IMM:
 139                         operand->type = OP_IMM;
 140                         p = eat_immediate(&operand->value, ++p, line_nr);
 141                         goto out;
 142                 case ASM_OP_REG:
 143                         operand->type = OP_REG;
 144                         p = eat_register(&operand->value, ++p, line_nr);
 145                         goto out;
 146                 default:
 147                         /* label */
 148                         operand->type = OP_IMM;
 149                         p = eat_label(&operand->value, p, line_nr);
 150                         goto out;
 151                 }
 152         }
 153
 154 out:
 155         return p;
 156 }
 157
 158 static void encode_arit(const struct operand *operands, inst_t *instruction)
 159 {
 160         int type;
 161         oper_t dest;
 162
 163         dest = operands[2].value;
 164         set_reg(instruction, dest, OFF_DEST);
 165
 166         type = operands[0].type | operands[1].type;
 167         if (type & OP_IMM) {
 168                 oper_t imm, src1;
 169
 170                 if (operands[0].type == OP_IMM) {
 171                         imm = operands[0].value;
 172                         src1 = operands[1].value;
 173                 } else {
 174                         imm = operands[1].value;
 175                         src1 = operands[0].value;
 176                 }
 177
 178                 set_reg(instruction, src1, OFF_SRC1);
 179                 set_reg(instruction, dest, OFF_IMM_DEST);
 180                 set_imm(instruction, imm);
 181         } else {
 182                 oper_t reg;
 183
 184                 reg = operands[0].value;
 185                 set_reg(instruction, reg, OFF_SRC1);
 186
 187                 reg = operands[1].value;
 188                 set_reg(instruction, reg, OFF_SRC2);
 189         }
 190 }
 191
 192 static void encode_branch(const struct operand *operands,
 193                           inst_t *instruction)
 194 {
 195         oper_t dest;
 196
 197         dest = operands[0].value;
 198
 199         if (operands[0].type & OP_IMM)
 200                 set_imm(instruction, dest);
 201         else
 202                 set_reg(instruction, dest, OFF_MEM_REG_SRC1);
 203 }
 204
 205 static void encode_store_imm(const struct operand *operands,
 206                              inst_t *instruction)
 207 {
 208         oper_t imm, src;
 209
 210         src = operands[0].value;
 211         set_reg(instruction, src, OFF_SRC1);
 212
 213         imm = operands[1].value;
 214         set_imm(instruction, imm);
 215 }
 216
 217 static int inst_is_store(inst_t instruction)
 218 {
 219         const int store = 0x3000;
 220
 221         return instruction == store;
 222 }
 223
 224 static int operands_has_imm(const struct operand *operands)
 225 {
 226         int i;
 227
 228         for (i = 0; i < OP_MAX; i++)
 229                 if (operands[i].type == OP_IMM)
 230                         return 1;
 231         return 0;
 232 }
 233
 234 static void encode_mem(const struct operand *operands,
 235                        inst_t *instruction)
 236 {
 237         oper_t src1, dest;
 238
 239         /* Fix this hack... */
 240         if (inst_is_store(*instruction) &&
 241             operands_has_imm(operands)) {
 242                 encode_store_imm(operands, instruction);
 243                 return;
 244         }
 245
 246         src1 = operands[0].value;
 247         dest = operands[1].value;
 248
 249         if (operands[0].type & OP_IMM) {
 250                 set_imm(instruction, src1);
 251                 set_reg(instruction, dest, OFF_MEM_IMM_DEST);
 252         } else {
 253                 set_reg(instruction, src1, OFF_MEM_REG_SRC1);
 254                 set_reg(instruction, dest, OFF_MEM_REG_DEST);
 255         }
 256 }
 257
 258 static void encode_comp(const struct operand *operands,
 259                         inst_t *instruction)
 260 {
 261         oper_t src1, src2;
 262
 263         src1 = operands[0].value;
 264
 265         src2 = operands[1].value;
 266         set_reg(instruction, src2, OFF_SRC2);
 267
 268         if (operands[0].type & OP_IMM)
 269                 set_imm(instruction, src1);
 270         else
 271                 set_reg(instruction, src1, OFF_SRC1);
 272 }
 273
 274 static void encode_inst(const struct opcode *opcode, inst_t *instruction)
 275 {
 276         *instruction = (inst_t) opcode->opcode << OFF_INST;
 277 }
 278
 279 static int check_operands(const struct opcode *opcode,
 280                           const struct operand *operands,
 281                           int operand_nr, int line_nr)
 282 {
 283         int i;
 284
 285         if (operand_nr > opcode->nr_operands) {
 286                 error(line_nr, "instruction only supports %d operands",
 287                       opcode->nr_operands);
 288                 return 1;
 289         }
 290
 291         for (i = 0; i < opcode->nr_operands; i++) {
 292                 if (opcode->operands[i].type == OP_INV &&
 293                     operands[i].type != OP_INV) {
 294                         error(line_nr, "instruction only accepts %d operands",
 295                               opcode->nr_operands);
 296                         return 1;
 297                 }
 298
 299                 if (operands[i].type == OP_INV &&
 300                     opcode->operands[i].type != OP_INV) {
 301                         error(line_nr, "operand %d is missing", i + 1);
 302                         return 1;
 303                 }
 304
 305                 if ((opcode->operands[i].type != OP_INV) &&
 306                     !(opcode->operands[i].type & operands[i].type)) {
 307                         error(line_nr, "wrong type for operand %d", i + 1);
 308                         return 1;
 309                 }
 310         }
 311
 312         return 0;
 313 }
 314
 315 static int assembly(const struct opcode *opcode,
 316                     const struct operand *operands,
 317                     int operand_nr, inst_t *instruction, int line_nr)
 318 {
 319         int err;
 320
 321         err = check_operands(opcode, operands, operand_nr, line_nr);
 322         if (err)
 323                 return -1;
 324
 325         encode_inst(opcode, instruction);
 326
 327         switch (opcode->type) {
 328         case INST_ARIT:
 329                 encode_arit(operands, instruction);
 330                 break;
 331         case INST_MEM:
 332                 encode_mem(operands, instruction);
 333                 break;
 334         case INST_BRAN:
 335                 encode_branch(operands, instruction);
 336                 break;
 337         case INST_COMP:
 338                 encode_comp(operands, instruction);
 339                 break;
 340         case INST_NARG:
 341                 /* do nothing */
 342                 break;
 343         };
 344
 345         return 0;
 346 }
 347
 348 static int read_operands(char *line, int line_nr, int operand_nr,
 349                          struct operand *operands)
 350 {
 351         int i;
 352         char *p;
 353
 354         // initialize
 355         for (i = 0; i < OP_MAX; i++) {
 356                 operands[i].value = 0;
 357                 operands[i].type = OP_INV;
 358         }
 359
 360         p = line;
 361
 362         /* read operands */
 363         for (i = 0; i < operand_nr; i++) {
 364                 p = get_next_operand(p, &operands[i], line_nr);
 365                 if (!p)
 366                         return -1;
 367
 368                 if (*p == '\0' || *p == ASM_COMMENT)
 369                         break;
 370         }
 371
 372         // number of operands doesn't start at 0
 373         if (i)
 374                 ++i;
 375
 376         return i;
 377 }
 378
 379 /*
 380  * das_pass2()
 381  *
 382  * Perform assembler second pass
 383  *
 384  *   o assembly instructions
 385  *   o report errors
 386  *
 387  * interfp: intermediate FILE pointer (input)
 388  * binfp:   binary FILE pointer (output)
 389  * debug:   debug mode
 390  */
 391 int das_pass2(FILE *interfp, FILE *binfp, int debug)
 392 {
 393         inst_t instruction;
 394         int line_nr, err, ret;
 395         struct opcode *opcode;
 396         char line[DEF_LINE_LEN], *p;
 397         struct operand operands[OP_MAX];
 398
 399         err = 0;
 400
 401         for (line_nr = 1; ; line_nr++) {
 402                 ret = file_read_line(interfp, line, DEF_LINE_LEN);
 403                 if (ret == 1)
 404                         break;
 405
 406                 if (is_comment(*line) || is_newline(*line))
 407                         continue;
 408
 409                 remove_comment(line, strlen(line));
 410
 411                 p = get_opcode(line, line_nr, &opcode);
 412                 if (!p) {
 413                         err = 1;
 414                         continue;
 415                 }
 416
 417                 ret = read_operands(p, line_nr, opcode->nr_operands, operands);
 418                 if (ret < 0) {
 419                         err = 1;
 420                         continue;
 421                 }
 422
 423                 ret = assembly(opcode, operands, ret, &instruction, line_nr);
 424                 if (ret) {
 425                         err = 1;
 426                         continue;
 427                 }
 428
 429                 file_write_bin(&instruction, sizeof(instruction), binfp);
 430
 431                 if (debug)
 432                         printf("%#x\n", instruction);
 433         }
 434
 435         return err;
 436 }