![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to opcodes.nw CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / sml / src / mips|
Return to opcodes.nw CVS log | Up to [Research Unix] / researchv10no / cmd / sml / src / mips |
1.1 ! root 1: \chapter{Handling the MIPS opcodes} ! 2: \section{Introduction} ! 3: ! 4: This file generates the code necessary to handle MIPS instructions ! 5: in a natural, mnemonic way from within ML. ! 6: All MIPS instructions occupy 32 bits, and since ML has no simple ! 7: 32~bit data type, we use pairs of integerss to represent MIPS instructions. ! 8: A pair [[(hi,lo)]] of 16-bit integers holds the most and least significant ! 9: halfwords of the MIPS word. ! 10: ML integers are 31 bits, so this is more than adequate. ! 11: ! 12: The biggest hassle in converting between these integer pairs and more ! 13: mnemonic representations is that it is too easy to make mistakes ! 14: (especially typographical errors) in writing the code. ! 15: For that reason, I have added an extra level of indirection to the ! 16: whole business by putting all of the instruction descriptions in ! 17: tables. ! 18: These tables are read by an awk script, which writes two ML files: ! 19: {\tt opcodes.sml} and {\tt mipsdecode.sml}. ! 20: The {\tt opcodes.sml} file contains the code needed to convert from ! 21: a mnemonic like [[add(3,4,9)]] (add the contents of register~3 to ! 22: the contents of register~4, placing the result in register~9) to ! 23: the integer pair representation of the actual bits in that add instruction ! 24: (in this case [[(137,6176)]]). ! 25: The {\tt mipsdecode.sml} file contains a [[decode]] function that converts ! 26: from the integer pair representation of instructions to a string ! 27: representation. ! 28: The string representation is a little hokey at the moment (that is, ! 29: it's different from the one used in the MIPS book), but it represents ! 30: a nice compromise between being readable and easy to generate. ! 31: ! 32: I have contemplating generating a third file to test the whole ! 33: business. ! 34: The idea would be to have a function that would write out (to files) ! 35: two ! 36: parallel representations of the same instruction stream (presumably ! 37: one copy of each known instruction). ! 38: One representation would be the binary one understood by the MIPS. ! 39: The other representation would be a string representation. ! 40: We could then use a tool like {\tt gdb} or {\tt adb} to print out ! 41: the binary as an instruction sequence (i.e. convert back to ! 42: a second string representation) and compare the string representations ! 43: to see if they make sense. ! 44: ! 45: \paragraph{Possible bugs} ! 46: This code should be gone over with care to make sure that negative ! 47: operands (e.g. in [[offset]]) won't break the code. ! 48: ! 49: ! 50: @ ! 51: We need a special line in the Makefile to handle this file, since ! 52: it writes both an awk program and that program's input. The input ! 53: is in module {\tt @<<opcodes table@>>} so the line is ! 54: $$\hbox{[[ $(NOTANGLE) '-Ropcodes table' opcodes.ow > opcodes]]}$$ ! 55: The input is nothing but a sequence of tables, each labelled, and ! 56: processed one after anothing according to the label. ! 57: The label is always a single word on a line by itself. ! 58: Tables end with blank lines. ! 59: @ The opcode-to-pair code is written to the standard output, in ! 60: [[structure Opcodes]]. ! 61: The pair-to-string code is written to [["mipsdecode.sml"]], in ! 62: [[structure MipsDecode]]. ! 63: ! 64: We begin by defining and and shift functions. ! 65: We make pessimistic assumptions about shifting, trying always to ! 66: keep the arguments between 0 and 31 inclusive. ! 67: <<BEGIN>>= ! 68: print "structure Opcodes = struct" ! 69: print "val andb = Bits.andb" ! 70: print "fun lshift(op1,amt) = " ! 71: print " if amt<0 then Bits.rshift(op1,0-amt)" ! 72: print " else Bits.lshift(op1,amt)" ! 73: print "nonfix sub" # bug fixes; want [[sub]] to be a MIPS opcode ! 74: print "nonfix div" # bug fixes; want [[div]] to be a MIPS opcode ! 75: ! 76: decode = "mipsdecode.sml"; ! 77: print "structure MipsDecode = struct" > decode ! 78: print "val andb = Bits.andb" > decode ! 79: print "fun rshift(op1,amt) = " > decode ! 80: print " if amt<0 then Bits.lshift(op1,0-amt)" > decode ! 81: print " else Bits.rshift(op1,amt)" > decode ! 82: <<END>>= ! 83: <<write out the definitions of the decoding functions>> ! 84: print "end (* Opcodes *)" ! 85: print "end (* Decode *)" > decode ! 86: @ The sections BEGIN and END are drawn from ! 87: our universal model of an awk program: ! 88: <<*>>= ! 89: BEGIN { ! 90: <<BEGIN>> ! 91: } ! 92: <<functions>> ! 93: <<statements>> ! 94: END { ! 95: <<END>> ! 96: } ! 97: @ \section{The opcode tables} ! 98: The numeric codes for all the MIPS opcodes are described in three ! 99: tables in the MIPS book on page~A-87. ! 100: Normal opcodes are six bits, and appear in the [[opcode]] field of the ! 101: instruction. ! 102: Two opcodes [[special]] and [[bcond]] stand for several instructions. ! 103: These instructions are decoded by checking the bit-pattern in the ! 104: [[funct]] and [[cond]] fields of the instructions, respectively. ! 105: ! 106: The tables show which opcodes correspond to which bit-patterns. ! 107: For example, the [[slti]] corresponds to an [[opcode]] value of octal~12. ! 108: The table headed [[opcode]] gives the mnemonics for all six-bit patterns ! 109: in the [[opcode]] field. ! 110: The [[special]] table shows patterns for the [[funct]] field, used with ! 111: the [[special]] opcode. ! 112: The [[bcond]] table shows five-bit patterns for the [[cond]] field, ! 113: used with the [[bcond]] opcode. ! 114: In all tables, stars ([[*]]) stand for unused fields. ! 115: ! 116: Each table is terminated with a blank line. ! 117: <<opcodes table>>= ! 118: opcode ! 119: special bcond j jal beq bne blez bgtz ! 120: addi addiu slti sltiu andi ori xori lui ! 121: cop0 cop1 cop2 cop3 * * * * ! 122: * * * * * * * * ! 123: lb lh lwl lw lbu lhu lwr * ! 124: sb sh swl sw * * swr * ! 125: lwc0 lwc1 lwc2 lwc3 * * * * ! 126: swc0 swc1 swc2 swc3 * * * * ! 127: ! 128: special ! 129: sll * srl sra sllv * srlv srav ! 130: jr jalr * * syscall break * * ! 131: mfhi mthi mflo mtlo * * * * ! 132: mult multu div divu * * * * ! 133: add addu sub subu and' or xor nor ! 134: * * slt sltu * * * * ! 135: * * * * * * * * ! 136: * * * * * * * * ! 137: ! 138: bcond ! 139: bltz bgez * * * * * * ! 140: * * * * * * * * ! 141: bltzal bgezal * * * * * * ! 142: * * * * * * * * ! 143: ! 144: ! 145: @ The instructions codes for Coprocessor 1 (floating point) ! 146: are takin from page B-28 of the Mips book. ! 147: <<opcodes table>>= ! 148: cop1 ! 149: add_fmt sub_fmt mul_fmt div_fmt * abs_fmt mov_fmt neg_fmt ! 150: * * * * * * * * ! 151: * * * * * * * * ! 152: * * * * * * * * ! 153: cvt_s cvt_d * * cvt_w * * * ! 154: * * * * * * * * ! 155: c_f c_un c_eq c_ueq c_olt c_ult c_ole c_ule ! 156: c_sf c_ngle c_seq c_ngl c_lt c_nge c_le c_ngt ! 157: ! 158: @ ! 159: Now we have to deal with reading these tables, and extracting the ! 160: information stored therein. ! 161: First of all, for each mnemonic [[$i]] we store the corresponding bit ! 162: pattern (as an integer, [[code]]) in the array [[numberof[$i] ]]. ! 163: Then, we store the type of the mnemonic (ordinary [[OPCODE]], ! 164: [[SPECIAL]], [[BCOND]], of [[COP1]]) in the array [[typeof[$i] ]]. ! 165: Finally, we store inverse (a map from type and bit pattern to mnemonic) ! 166: in the [[opcode]] array. ! 167: <<store opcode information>>= ! 168: if ($i != "*") { ! 169: numberof[$i] = code ! 170: typeof[$i] = type ! 171: opcode[type,code] = $i ! 172: } else { ! 173: opcode[type,code] = "reserved" ! 174: } ! 175: @ The types are just constants set at the beginning. ! 176: <<BEGIN>>= ! 177: OPCODE = 1 ; SPECIAL = 2 ; BCOND = 3 ; COP1 = 4 ! 178: @ We determine the type by scanning the header word that precedes ! 179: each table. ! 180: Once we see the appropriate table header, we set one of [[opcodes]], ! 181: [[specials]], and [[bconds]], so that determining the type is easy: ! 182: <<set [[type]]>>= ! 183: type = OPCODE * opcodes + SPECIAL * specials + BCOND * bconds + COP1 * cop1s ! 184: @ Seeing the right table header causes us to set the right variable. ! 185: We also remember the line number, because we use the positions of later ! 186: lines to help extract the bit patterns from the table. ! 187: <<statements>>= ! 188: NF == 1 && $1 == "opcode" { ! 189: startline = NR ! 190: opcodes = 1 ! 191: next ! 192: } ! 193: NF == 1 && $1 == "special" { ! 194: startline = NR ! 195: specials = 1 ! 196: next ! 197: } ! 198: NF == 1 && $1 == "bcond" { ! 199: startline = NR ! 200: bconds = 1 ! 201: next ! 202: } ! 203: NF == 1 && $1 == "cop1" { ! 204: startline = NR ! 205: cop1s = 1 ! 206: next ! 207: } ! 208: @ Any time we see a blank line, that ends the appropriate table. ! 209: <<statements>>= ! 210: NF == 0 {opcodes = 0; specials = 0; bconds = 0; cop1s = 0 ! 211: <<blank line resets>> ! 212: } ! 213: @ Here is the code that actually extracts the bit patterns from ! 214: the opcode tables. ! 215: The code is the same for each of the three tables. ! 216: ! 217: The [[insist_fields(8)]] issues an error message and returns false (0) ! 218: unless there are exactly 8 fields on the input line. ! 219: <<statements>>= ! 220: opcodes || specials || bconds || cop1s { ! 221: if (!insist_fields(8)) next ! 222: <<set [[type]]>> ! 223: major = NR - startline - 1 # major octal digit from row ! 224: for (i=1; i<= NF; i++) { ! 225: minor = i-1 # minor octal digit from column ! 226: code = minor + 8 * major ! 227: <<store opcode information>> ! 228: } ! 229: } ! 230: @ \section{The instruction fields} ! 231: Now that we've dealt with the opcodes, we'll handle other fields of ! 232: the instruction. ! 233: This table tells us the position of each field within the word, ! 234: so that if we know a bit-pattern for each field, we can assemble ! 235: all the fields into an instruction. ! 236: ! 237: Not all fields are used in all instructions. ! 238: Later we'll have a table that indicates exactly which fields are used in ! 239: which instructions. ! 240: For now, we just list the fields and their positions with the ! 241: understanding that some fields will overlap. ! 242: ! 243: The table is taken from the MIPS book, page A-3. ! 244: The numbers are the numbers of the starting and ending bit positions, ! 245: where 0 is the least and 31 the most significant bit. ! 246: The names are exactly those used in the book except [[op']] has been ! 247: substituted for [[op]] since [[op]] is a reserved word in ML. ! 248: ! 249: If a field is signed, we put a [[+]]~sign as the first character ! 250: of its name. ! 251: The sign information is used only in decoding (I think). ! 252: <<opcodes table>>= ! 253: fields ! 254: op' 26 31 ! 255: rs 21 25 ! 256: rt 16 20 ! 257: +immed 0 15 ! 258: +offset 0 15 ! 259: base 21 25 ! 260: target 0 25 ! 261: rd 11 15 ! 262: shamt 6 10 ! 263: funct 0 5 ! 264: cond 16 20 ! 265: <<floating point load/store fields>> ! 266: <<floating point computation fields>> ! 267: ! 268: @ From page B-5. Most fields are the same as the CPU instruction formats. ! 269: <<floating point load/store fields>>= ! 270: ft 16 20 ! 271: @ From page B-6. Many fields are reused from earlier specifications. ! 272: The computational instructions all have a one bit in position 25. ! 273: Instead of trying to insert special code to handle that, we cheat on ! 274: it by making that bit part of the format, and cheating on the format. ! 275: Thus: ! 276: <<floating point computation fields>>= ! 277: fmt 21 25 ! 278: fs 11 15 ! 279: fd 6 10 ! 280: <<write format info>>= ! 281: print "val S_fmt = 16+0" ! 282: print "val D_fmt = 16+1" ! 283: print "val W_fmt = 16+4" ! 284: ! 285: @ The setup for the fields is similar to that used for the opcodes. ! 286: <<statements>>= ! 287: NF == 1 && $1 == "fields" { ! 288: startline = NR ! 289: fields = 1 ! 290: <<write format info>> ! 291: next ! 292: } ! 293: <<blank line resets>>= ! 294: fields = 0 ! 295: <<statements>>= ! 296: fields { ! 297: if (!insist_fields(3)) next ! 298: fieldname = $1; low = $2; high = $3 ! 299: <<look for sign in [[fieldname]] and set [[signed]]>> ! 300: fieldnames[fieldname]= 1 # rememeber all the field names ! 301: ! 302: <<write to standard output a function to convert bit-pattern to pair>> ! 303: <<write to [[decode]] a function to extract field from pair>> ! 304: ! 305: } ! 306: <<look for sign in [[fieldname]] and set [[signed]]>>= ! 307: if (substr(fieldname,1,1)=="+") { ! 308: signed = 1 ! 309: fieldname = substr(fieldname,2) ! 310: } else { ! 311: signed = 0 ! 312: } ! 313: @ ! 314: The idea is that for each of these fields, we want to write a function ! 315: that will take an integer argument and shift it by the right amount. ! 316: Since we have to represent the 32-bit quantities as pairs of integers, ! 317: we actually use two functions, one for the high half and one for the low. ! 318: So, for example, for the [[rd]] field we will produce two function definitions, ! 319: [[rdHI]] and [[rdLO]]. ! 320: ! 321: The awk function [[function_definition]] is used to compute ML function ! 322: definitions. ! 323: It takes as arguments the name of the function and the number of arguments ! 324: to that function. ! 325: The arguments are numbered [[A1]], [[A2]], et cetera. ! 326: ! 327: The functions themselves are all tedious combinations of ands and shifts. ! 328: At one time I had convinced myself that this worked. ! 329: <<write to standard output a function to convert bit-pattern to pair>>= ! 330: if (low >= 16) { ! 331: printf "%s", function_definition(fieldname "LO",1); print "0" ! 332: } else { ! 333: printf "%s", function_definition(fieldname "LO",1) ! 334: printf "andb(lshift(A1,%d),65535)\n", low ! 335: } ! 336: if (high < 16) { ! 337: printf "%s", function_definition(fieldname "HI",1); print "0" ! 338: } else { ! 339: printf "%s", function_definition(fieldname "HI",1) ! 340: printf "lshift(A1,%s)\n", mlnumber(low - 16) ! 341: } ! 342: @ The inverse operation is ! 343: to extract a bit pattern from a pair. ! 344: We'll want that if we ever care to decode instructions. ! 345: This time, the function to extract e.g.\ field [[rd]] from a pair ! 346: is the function [[THErd]] applied to that pair. ! 347: ! 348: The functions work first by extracting from the low part, then ! 349: from the high part, and adding everything together. ! 350: If the field is signed, we make the value negative if it is too high. ! 351: <<write to [[decode]] a function to extract field from pair>>= ! 352: printf "%s", function_definition("THE" fieldname,2) > decode ! 353: if (signed) printf "let val n = " > decode ! 354: <<print expression for unsigned value>> ! 355: if (signed) { ! 356: printf "in if n < %d then n else n - %d\nend\n", ! 357: 2**(high-low), 2**(high-low+1) > decode ! 358: } ! 359: ! 360: <<print expression for unsigned value>>= ! 361: if (low >= 16) { ! 362: printf "0" > decode ! 363: } else { ! 364: printf "andb(rshift(A2,%d),%d)", low, ! 365: (2**(min(15,high)-low+1)-1) > decode ! 366: } ! 367: printf " + " > decode ! 368: if (high < 16) { ! 369: printf "0\n" > decode ! 370: } else { ! 371: printf "rshift(andb(A1,%d),%s)\n", (2**(high-16+1)-1), ! 372: mlnumber(low - 16) > decode ! 373: } ! 374: @ ML uses a strange minus sign ([[~]] instead of [[-]]), ! 375: so we print numbers that might be negative like this: ! 376: <<functions>>= ! 377: function mlnumber(n, s) { ! 378: if (n<0) s = sprintf("~%d", -n) ! 379: else s = sprintf("%d", n) ! 380: return s ! 381: } ! 382: @ For reasons best known to its designers, awk has no [[min]] function. ! 383: <<functions>>= ! 384: function min(x,y){ ! 385: if (x<y) return x ! 386: else return y ! 387: } ! 388: @ \section{The list of instructions and their formats} ! 389: This is the section that tells which fields are used in what instructions, ! 390: and in what order the fields appear. ! 391: The information is from Appendix A ! 392: of the MIPS book and should be proofread. ! 393: ! 394: To cut down on the number of ML functions generated, we can comment out ! 395: instructions with a [[#]] in the first column. ! 396: This means that no code will be generated for the instruction, and ! 397: it won't appear in the [[structure Opcodes]]. ! 398: <<opcodes table>>= ! 399: instructions ! 400: add rd rs rt ! 401: addi rt rs immed ! 402: addiu rt rs immed ! 403: addu rd rs rt ! 404: and' rd rs rt ! 405: andi rt rs immed ! 406: beq rs rt offset ! 407: bgez rs offset ! 408: bgezal rs offset ! 409: bgtz rs offset ! 410: blez rs offset ! 411: bltz rs offset ! 412: bltzal rs offset ! 413: bne rs rt offset ! 414: break ! 415: div rs rt ! 416: divu rs rt ! 417: j target ! 418: jal target ! 419: jalr rs rd ! 420: jr rs ! 421: lb rt offset base ! 422: lbu rt offset base ! 423: lh rt offset base ! 424: lb rt offset base ! 425: lhu rt offset base ! 426: lui rt immed ! 427: lw rt offset base ! 428: lwl rt offset base ! 429: lwr rt offset base ! 430: mfhi rd ! 431: mflo rd ! 432: mthi rs ! 433: mtlo rs ! 434: mult rs rt ! 435: multu rs rt ! 436: nor rd rs rt ! 437: or rd rs rt ! 438: ori rt rs immed ! 439: sb rt offset base ! 440: sh rt offset base ! 441: sll rd rt shamt ! 442: sllv rd rt rs ! 443: slt rd rs rt ! 444: slti rt rs immed ! 445: sltiu rt rs immed ! 446: sltu rd rs rt ! 447: sra rd rt shamt ! 448: srav rd rt rs ! 449: srl rd rt shamt ! 450: srlv rd rt rs ! 451: sub rd rs rt ! 452: subu rd rs rt ! 453: sw rt offset base ! 454: swl rt offset base ! 455: swr rt offset base ! 456: syscall ! 457: xor rd rs rt ! 458: xori rt rs immed ! 459: <<floating point instructions>> ! 460: ! 461: ! 462: @ We define only those floating point instructions we seem likely to need. ! 463: To distinguish them as floating point we append an f to their names. ! 464: <<floating point instructions>>= ! 465: add_fmt fmt fd fs ft ! 466: div_fmt fmt fd fs ft ! 467: lwc1 ft offset base ! 468: mul_fmt fmt fd fs ft ! 469: neg_fmt fmt fd fs ! 470: sub_fmt fmt fd fs ft ! 471: swc1 ft offset base ! 472: c_seq fmt fs ft ! 473: c_lt fmt fs ft ! 474: @ ! 475: Here is a terrible hack to enable us to construct branch on coprocessor~1 ! 476: true or false. ! 477: We will use [[fun bc1f offset = cop1(0,offset)]] and ! 478: [[fun bc1t offset = cop1(1,offset)]]. ! 479: <<floating point instructions>>= ! 480: cop1 rs rt offset ! 481: @ ! 482: ! 483: ! 484: @ For each instruction, we define an ML function with the appropriate ! 485: number of arguments. ! 486: When that function is given an integer in each argument, ! 487: it converts the whole thing to one MIPS instruction, represented as an ! 488: integer pair. ! 489: ! 490: The implementation is a bit of a grubby mess. ! 491: Doing the fields is straightforward enough, but ! 492: for each mnemonic we have to do something different based ! 493: on its type, because each type of opcode goes in a different ! 494: field. ! 495: Moreover, for mnemonics of type [[SPECIAL]], [[BCOND]], and [[COP1]] we ! 496: have to generate [[special]], [[bcond]], and [[cop1]] in the [[op']] field. ! 497: Finally, we have to do it all twice; once for the high order ! 498: halfword and once for the low order halfword. ! 499: <<compute function that generates this instruction>>= ! 500: printf "%s", function_definition(opname, NF-1) ! 501: printf "(" # open parenthesis for pair ! 502: for (i=2; i<= NF; i++) { ! 503: if (!($i in fieldnames)) <<bad field name>> ! 504: printf "%sHI(A%d)+", $i, i-1 ! 505: } ! 506: if (typeof[opname]==OPCODE) { ! 507: printf "op'HI(%d)", numberof[opname] ! 508: } else if (typeof[opname]==SPECIAL) { ! 509: printf "op'HI(%d)+", numberof["special"] ! 510: printf "functHI(%d)", numberof[opname] ! 511: } else if (typeof[opname]==BCOND) { ! 512: printf "op'HI(%d)+", numberof["bcond"] ! 513: printf "condHI(%d)", numberof[opname] ! 514: } else if (typeof[opname]==COP1) { ! 515: printf "op'HI(%d)+", numberof["cop1"] ! 516: printf "functHI(%d)", numberof[opname] ! 517: } else <<bad operator name>> ! 518: printf ", " ! 519: for (i=2; i<= NF; i++) { ! 520: if (!($i in fieldnames)) <<bad field name>> ! 521: printf "%sLO(A%d)+", $i, i-1 ! 522: } ! 523: if (typeof[opname]==OPCODE) { ! 524: printf "op'LO(%d)", numberof[opname] ! 525: } else if (typeof[opname]==SPECIAL) { ! 526: printf "op'LO(%d)+", numberof["special"] ! 527: printf "functLO(%d)", numberof[opname] ! 528: } else if (typeof[opname]==BCOND) { ! 529: printf "op'LO(%d)+", numberof["bcond"] ! 530: printf "condLO(%d)", numberof[opname] ! 531: } else if (typeof[opname]==COP1) { ! 532: printf "op'LO(%d)+", numberof["cop1"] ! 533: printf "functLO(%d)", numberof[opname] ! 534: } else <<bad operator name>> ! 535: printf ")\n" ! 536: @ ! 537: Setup is as before. ! 538: <<statements>>= ! 539: NF == 1 && $1 == "instructions" { ! 540: startline = NR ! 541: instructions = 1 ! 542: next ! 543: } ! 544: <<blank line resets>>= ! 545: instructions= 0 ! 546: <<statements>>= ! 547: instructions && $0 !~ /^#/ { ! 548: opname = $1 ! 549: ! 550: <<compute string displayed when this instruction is decoded>> ! 551: ######## gsub("[^a-z']+"," ") ### ill-advised ! 552: ! 553: <<compute function that generates this instruction>> ! 554: } ! 555: ! 556: @ \paragraph{Decoding instructions} ! 557: When we've decoded an instruction, we have to display some sort of ! 558: string representation that tells us what the instruction is. ! 559: Ideally we should display either just what the assembler expects, ! 560: or perhaps just what dbx displays when asked about actual instructions ! 561: in memory images. ! 562: ! 563: For now, we just give the mnemonic for the instruction, followed ! 564: by a description of each field (followed by a newline). ! 565: The fields are described as name-value pairs. ! 566: ! 567: We rely on the fact that for a field e.g.\ [[rd]], the string ! 568: representation of the value of that field is in [[Srd]]. ! 569: <<compute string displayed when this instruction is decoded>>= ! 570: temp = "\"" opname " \"" ! 571: for (i=2; i<=NF; i++) { ! 572: temp = sprintf( "%s ^ \"%s = \" ^ S%s", temp, $i, $i) ! 573: if (i<NF) temp = sprintf("%s ^ \",\" ", temp) ! 574: } ! 575: displayof[opname]=temp " ^ \"\\n\"" ! 576: ! 577: @ The implementation of the decoding function is split into several parts. ! 578: First, we have to be able to extract any field from an instruction. ! 579: Then, we have to be able to decode four kinds of opcodes: ! 580: [[OPCODE]]s, [[BCOND]]s, [[SPECIAL]]s, and [[COP1]]s. ! 581: The main function is the one that does ordinary opcodes. ! 582: The others are auxiliary. ! 583: <<write out the definitions of the decoding functions>>= ! 584: printf "%s", function_definition("decode",2) > decode ! 585: print "let" > decode ! 586: <<write definitions of integer and string representations of each field>> ! 587: <<write expression that decodes the [[funct]] field for [[special]]s>> ! 588: <<write expression that decodes the [[cond]] field for [[bcond]]s>> ! 589: <<write expression that decodes the [[funct]] field for [[cop1]]s>> ! 590: print "in" > decode ! 591: <<write [[case]] expression that decodes the [[op']] field for each instruction>> ! 592: print "end" > decode ! 593: @ We give each field its own name for an integer version, and its name ! 594: preceded by [[S]] for its string version. ! 595: These values are all computed just once, from the arguments to the ! 596: enclosing function ([[decode]]). ! 597: <<write definitions of integer and string representations of each field>>= ! 598: for (f in fieldnames) { ! 599: printf "val %s = THE%s(A1,A2)\n", f, f > decode ! 600: printf "val S%s = Integer.makestring %s\n", f, f > decode ! 601: } ! 602: @ The next three functions are very much of a piece. ! 603: They are just enormous [[case]] expressions that match up integers ! 604: (bit patterns) to strings. ! 605: The fundamental operation is printing out a decimal value and a string ! 606: for each opcode: ! 607: <<if [[name]] is known, display a case for it>>= ! 608: if (name != "" && name != "reserved") { ! 609: <<print space or bar ([[|]])>> ! 610: disp = displayof[name] ! 611: if (disp=="") disp="\"" name "(??? unknown format???)\\n\"" ! 612: printf "%d => %s\n", code, disp > decode ! 613: } ! 614: @ Cases must be separated by vertical bars. ! 615: We do the separation by putting a vertical bar before each case except ! 616: the first. ! 617: We use a hack to discover the first; we assume that code~0 is always ! 618: defined, and so it will always be the first. ! 619: <<print space or bar ([[|]])>>= ! 620: if (code!=0) printf " | " > decode # hack but it works ! 621: else printf " " > decode ! 622: <<write expression that decodes the [[funct]] field for [[special]]s>>= ! 623: print "val do_special =" > decode ! 624: print "(case funct of" > decode ! 625: for (code=0; code<256; code++) { ! 626: name = opcode[SPECIAL,code] ! 627: <<if [[name]] is known, display a case for it>> ! 628: } ! 629: printf " | _ => \"unknown special\\n\"\n" > decode ! 630: print " ) " > decode ! 631: <<write expression that decodes the [[cond]] field for [[bcond]]s>>= ! 632: print "val do_bcond =" > decode ! 633: print "(case cond of" > decode ! 634: for (code=0; code<256; code++) { ! 635: name = opcode[BCOND,code] ! 636: <<if [[name]] is known, display a case for it>> ! 637: } ! 638: printf " | _ => \"unknown bcond\\n\"\n" > decode ! 639: print " ) " > decode ! 640: <<write expression that decodes the [[funct]] field for [[cop1]]s>>= ! 641: print "val do_cop1 =" > decode ! 642: print "(case funct of" > decode ! 643: for (code=0; code<256; code++) { ! 644: name = opcode[COP1,code] ! 645: <<if [[name]] is known, display a case for it>> ! 646: } ! 647: printf " | _ => \"unknown cop1\\n\"\n" > decode ! 648: print " ) " > decode ! 649: @ The major expression is a little more complicated, because it has to ! 650: check for [[special]], [[bcond]], and [[cop1]] and handle those separately. ! 651: <<write [[case]] expression that decodes the [[op']] field for each instruction>>= ! 652: print "(case op' of" > decode ! 653: for (code=0; code<256; code++) { ! 654: name = opcode[OPCODE,code] ! 655: if (name=="special") { ! 656: <<print space or bar ([[|]])>> ! 657: printf "%d => %s\n", code, "do_special" > decode ! 658: } else if (name=="bcond") { ! 659: <<print space or bar ([[|]])>> ! 660: printf "%d => %s\n", code, "do_bcond" > decode ! 661: } else if (name=="cop1") { ! 662: <<print space or bar ([[|]])>> ! 663: printf "%d => %s\n", code, "do_cop1" > decode ! 664: } else <<if [[name]] is known, display a case for it>> ! 665: } ! 666: printf " | _ => \"unknown opcode\\n\"\n" > decode ! 667: print " ) " > decode ! 668: @ \section{testing} ! 669: One day someone will have to modify the instruction handler so that ! 670: it generates a test invocation of each instruction. ! 671: Then the results can be handed to something like adb or dbx and we can ! 672: see whether the system agrees with us about what we're generating. ! 673: ! 674: @ \section{Defining ML functions} ! 675: The awk function [[function_definition]] is used to ! 676: come up with ML function definitions. ! 677: It takes as arguments the name of the function and the number of arguments ! 678: to that function, and returns a string containing the initial part of ! 679: the function definition. ! 680: Writing an expression following that string will result in a complete ! 681: ML function. ! 682: ! 683: If we ever wanted to define these things as C preprocessor macros instead, ! 684: we could do it by substituting [[macro_definition]]. ! 685: I'm not sure it would ever make sense to do so, but I'm leaving the ! 686: code here anyway. ! 687: <<functions>>= ! 688: function function_definition(name, argc, i, temp) { ! 689: if (argc==0) { ! 690: temp = sprintf("val %s = ", name) ! 691: } else { ! 692: temp = sprintf( "fun %s(", name) ! 693: for (i=1; i< argc; i++) temp = sprintf("%sA%d,", temp,i) ! 694: temp = sprintf( "%sA%d) = ", temp, argc) ! 695: } ! 696: return temp ! 697: } ! 698: <<useless functions>>= ! 699: function macro_definition(name, argc, i, temp) { ! 700: if (argc==0) { ! 701: temp = sprintf("#define %s ", name) ! 702: } else { ! 703: temp = sprintf( "#define %s(", name) ! 704: for (i=1; i< argc; i++) temp = sprintf("%sA%d,", temp,i) ! 705: temp = sprintf( "%sA%d) ", temp, argc) ! 706: } ! 707: return temp ! 708: } ! 709: @ \section{Handling error conditions} ! 710: Here are a bunch of uninteresting functions and modules ! 711: that handle error conditions. ! 712: <<bad operator name>>= ! 713: { ! 714: print "unknown opcode", opname, "on line", NR > stderr ! 715: next ! 716: } ! 717: <<bad field name>>= ! 718: { ! 719: print "unknown field", $i, "on line", NR > stderr ! 720: next ! 721: } ! 722: <<BEGIN>>= ! 723: stderr="/dev/tty" ! 724: <<functions>>= ! 725: function insist_fields(n) { ! 726: if (NF != n) { ! 727: print "Must have", n, "fields on line",NR ":", $0 > stderr ! 728: return 0 ! 729: } else { ! 730: return 1 ! 731: } ! 732: } ! 733: @ \section{Leftover junk} ! 734: Like a pack rat, I never throw out anything that might be useful again later. ! 735: <<junk>>= ! 736: function thetype(n) { ! 737: if (n==OPCODE) return "OPCODE" ! 738: else if (n==SPECIAL) return "SPECIAL" ! 739: else if (n==BCOND) return "BCOND" ! 740: else if (n==COP1) return "COP1" ! 741: else return "BADTYPE" ! 742: } ! 743: <<decoding junk>>= ! 744: for (f in fieldnames) { ! 745: printf "^ \"\\n%s = \" ^ Integer.makestring %s\n",f,f > decode ! 746: } ! 747: printf "^\"\\n\"\n" > decode
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.