vm/mterp/gen-mterp.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (C) 2007 The Android Open Source Project
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #      http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 #
  18 # Using instructions from an architecture-specific config file, generate C
  19 # and assembly source files for the Dalvik interpreter.
  20 #
  21
  22 import sys, string, re, time
  23 from string import Template
  24
  25 interp_defs_file = "../../libdex/DexOpcodes.h" # need opcode list
  26 kNumPackedOpcodes = 512 # TODO: Derive this from DexOpcodes.h.
  27
  28 splitops = False
  29 verbose = False
  30 handler_size_bits = -1000
  31 handler_size_bytes = -1000
  32 in_op_start = 0             # 0=not started, 1=started, 2=ended
  33 in_alt_op_start = 0         # 0=not started, 1=started, 2=ended
  34 default_op_dir = None
  35 default_alt_stub = None
  36 opcode_locations = {}
  37 alt_opcode_locations = {}
  38 asm_stub_text = []
  39 label_prefix = ".L"         # use ".L" to hide labels from gdb
  40 alt_label_prefix = ".L_ALT" # use ".L" to hide labels from gdb
  41 style = None                # interpreter style
  42 generate_alt_table = False
  43
  44 # Exception class.
  45 class DataParseError(SyntaxError):
  46     "Failure when parsing data file"
  47
  48 #
  49 # Set any omnipresent substitution values.
  50 #
  51 def getGlobalSubDict():
  52     return { "handler_size_bits":handler_size_bits,
  53              "handler_size_bytes":handler_size_bytes }
  54
  55 #
  56 # Parse arch config file --
  57 # Set interpreter style.
  58 #
  59 def setHandlerStyle(tokens):
  60     global style
  61     if len(tokens) != 2:
  62         raise DataParseError("handler-style requires one argument")
  63     style = tokens[1]
  64     if style != "computed-goto" and style != "jump-table" and style != "all-c":
  65         raise DataParseError("handler-style (%s) invalid" % style)
  66
  67 #
  68 # Parse arch config file --
  69 # Set handler_size_bytes to the value of tokens[1], and handler_size_bits to
  70 # log2(handler_size_bytes).  Throws an exception if "bytes" is not 0 or
  71 # a power of two.
  72 #
  73 def setHandlerSize(tokens):
  74     global handler_size_bits, handler_size_bytes
  75     if style != "computed-goto":
  76         print "Warning: handler-size valid only for computed-goto interpreters"
  77     if len(tokens) != 2:
  78         raise DataParseError("handler-size requires one argument")
  79     if handler_size_bits != -1000:
  80         raise DataParseError("handler-size may only be set once")
  81
  82     # compute log2(n), and make sure n is 0 or a power of 2
  83     handler_size_bytes = bytes = int(tokens[1])
  84     bits = -1
  85     while bytes > 0:
  86         bytes //= 2     # halve with truncating division
  87         bits += 1
  88
  89     if handler_size_bytes == 0 or handler_size_bytes != (1 << bits):
  90         raise DataParseError("handler-size (%d) must be power of 2" \
  91                 % orig_bytes)
  92     handler_size_bits = bits
  93
  94 #
  95 # Parse arch config file --
  96 # Copy a file in to the C or asm output file.
  97 #
  98 def importFile(tokens):
  99     if len(tokens) != 2:
 100         raise DataParseError("import requires one argument")
 101     source = tokens[1]
 102     if source.endswith(".cpp"):
 103         appendSourceFile(tokens[1], getGlobalSubDict(), c_fp, None)
 104     elif source.endswith(".S"):
 105         appendSourceFile(tokens[1], getGlobalSubDict(), asm_fp, None)
 106     else:
 107         raise DataParseError("don't know how to import %s (expecting .cpp/.S)"
 108                 % source)
 109
 110 #
 111 # Parse arch config file --
 112 # Copy a file in to the C or asm output file.
 113 #
 114 def setAsmStub(tokens):
 115     global asm_stub_text
 116     if style == "all-c":
 117         print "Warning: asm-stub ignored for all-c interpreter"
 118     if len(tokens) != 2:
 119         raise DataParseError("import requires one argument")
 120     try:
 121         stub_fp = open(tokens[1])
 122         asm_stub_text = stub_fp.readlines()
 123     except IOError, err:
 124         stub_fp.close()
 125         raise DataParseError("unable to load asm-stub: %s" % str(err))
 126     stub_fp.close()
 127
 128 #
 129 # Parse arch config file --
 130 # Record location of default alt stub
 131 #
 132 def setAsmAltStub(tokens):
 133     global default_alt_stub, generate_alt_table
 134     if style == "all-c":
 135         print "Warning: asm-alt-stub ingored for all-c interpreter"
 136     if len(tokens) != 2:
 137         raise DataParseError("import requires one argument")
 138     default_alt_stub = tokens[1]
 139     generate_alt_table = True
 140
 141 #
 142 # Parse arch config file --
 143 # Start of opcode list.
 144 #
 145 def opStart(tokens):
 146     global in_op_start
 147     global default_op_dir
 148     if len(tokens) != 2:
 149         raise DataParseError("opStart takes a directory name argument")
 150     if in_op_start != 0:
 151         raise DataParseError("opStart can only be specified once")
 152     default_op_dir = tokens[1]
 153     in_op_start = 1
 154
 155 #
 156 # Parse arch config file --
 157 # Set location of a single alt opcode's source file.
 158 #
 159 def altEntry(tokens):
 160     global generate_alt_table
 161     if len(tokens) != 3:
 162         raise DataParseError("alt requires exactly two arguments")
 163     if in_op_start != 1:
 164         raise DataParseError("alt statements must be between opStart/opEnd")
 165     try:
 166         index = opcodes.index(tokens[1])
 167     except ValueError:
 168         raise DataParseError("unknown opcode %s" % tokens[1])
 169     if alt_opcode_locations.has_key(tokens[1]):
 170         print "Note: alt overrides earlier %s (%s -> %s)" \
 171                 % (tokens[1], alt_opcode_locations[tokens[1]], tokens[2])
 172     alt_opcode_locations[tokens[1]] = tokens[2]
 173     generate_alt_table = True
 174
 175 #
 176 # Parse arch config file --
 177 # Set location of a single opcode's source file.
 178 #
 179 def opEntry(tokens):
 180     #global opcode_locations
 181     if len(tokens) != 3:
 182         raise DataParseError("op requires exactly two arguments")
 183     if in_op_start != 1:
 184         raise DataParseError("op statements must be between opStart/opEnd")
 185     try:
 186         index = opcodes.index(tokens[1])
 187     except ValueError:
 188         raise DataParseError("unknown opcode %s" % tokens[1])
 189     if opcode_locations.has_key(tokens[1]):
 190         print "Note: op overrides earlier %s (%s -> %s)" \
 191                 % (tokens[1], opcode_locations[tokens[1]], tokens[2])
 192     opcode_locations[tokens[1]] = tokens[2]
 193
 194 #
 195 # Emit jump table
 196 #
 197 def emitJmpTable(start_label, prefix):
 198     asm_fp.write("\n    .global %s\n" % start_label)
 199     asm_fp.write("    .text\n")
 200     asm_fp.write("%s:\n" % start_label)
 201     for i in xrange(kNumPackedOpcodes):
 202         op = opcodes[i]
 203         dict = getGlobalSubDict()
 204         dict.update({ "opcode":op, "opnum":i })
 205         asm_fp.write("    .long " + prefix + \
 206                      "_%(opcode)s /* 0x%(opnum)02x */\n" % dict)
 207
 208 #
 209 # Parse arch config file --
 210 # End of opcode list; emit instruction blocks.
 211 #
 212 def opEnd(tokens):
 213     global in_op_start
 214     if len(tokens) != 1:
 215         raise DataParseError("opEnd takes no arguments")
 216     if in_op_start != 1:
 217         raise DataParseError("opEnd must follow opStart, and only appear once")
 218     in_op_start = 2
 219
 220     loadAndEmitOpcodes()
 221     if splitops == False:
 222         if generate_alt_table:
 223             loadAndEmitAltOpcodes()
 224             if style == "jump-table":
 225                 emitJmpTable("dvmAsmInstructionStart", label_prefix);
 226                 emitJmpTable("dvmAsmAltInstructionStart", alt_label_prefix);
 227
 228 def genaltop(tokens):
 229     if in_op_start != 2:
 230        raise DataParseError("alt-op can be specified only after op-end")
 231     if len(tokens) != 1:
 232         raise DataParseError("opEnd takes no arguments")
 233     if generate_alt_table:
 234         loadAndEmitAltOpcodes()
 235         if style == "jump-table":
 236             emitJmpTable("dvmAsmInstructionStart", label_prefix);
 237             emitJmpTable("dvmAsmAltInstructionStart", alt_label_prefix);
 238
 239
 240 #
 241 # Extract an ordered list of instructions from the VM sources.  We use the
 242 # "goto table" definition macro, which has exactly kNumPackedOpcodes
 243 # entries.
 244 #
 245 def getOpcodeList():
 246     opcodes = []
 247     opcode_fp = open(interp_defs_file)
 248     opcode_re = re.compile(r"^\s*H\(OP_(\w+)\),.*", re.DOTALL)
 249     for line in opcode_fp:
 250         match = opcode_re.match(line)
 251         if not match:
 252             continue
 253         opcodes.append("OP_" + match.group(1))
 254     opcode_fp.close()
 255
 256     if len(opcodes) != kNumPackedOpcodes:
 257         print "ERROR: found %d opcodes in Interp.h (expected %d)" \
 258                 % (len(opcodes), kNumPackedOpcodes)
 259         raise SyntaxError, "bad opcode count"
 260     return opcodes
 261
 262 def emitAlign():
 263     if style == "computed-goto":
 264         asm_fp.write("    .balign %d\n" % handler_size_bytes)
 265
 266 #
 267 # Load and emit opcodes for all kNumPackedOpcodes instructions.
 268 #
 269 def loadAndEmitOpcodes():
 270     sister_list = []
 271     assert len(opcodes) == kNumPackedOpcodes
 272     need_dummy_start = False
 273     if style == "jump-table":
 274         start_label = "dvmAsmInstructionStartCode"
 275         end_label = "dvmAsmInstructionEndCode"
 276     else:
 277         start_label = "dvmAsmInstructionStart"
 278         end_label = "dvmAsmInstructionEnd"
 279
 280     # point dvmAsmInstructionStart at the first handler or stub
 281     asm_fp.write("\n    .global %s\n" % start_label)
 282     asm_fp.write("    .type   %s, %%function\n" % start_label)
 283     asm_fp.write("%s = " % start_label + label_prefix + "_OP_NOP\n")
 284     asm_fp.write("    .text\n\n")
 285
 286     for i in xrange(kNumPackedOpcodes):
 287         op = opcodes[i]
 288
 289         if opcode_locations.has_key(op):
 290             location = opcode_locations[op]
 291         else:
 292             location = default_op_dir
 293
 294         if location == "c":
 295             loadAndEmitC(location, i)
 296             if len(asm_stub_text) == 0:
 297                 need_dummy_start = True
 298         else:
 299             loadAndEmitAsm(location, i, sister_list)
 300
 301     # For a 100% C implementation, there are no asm handlers or stubs.  We
 302     # need to have the dvmAsmInstructionStart label point at OP_NOP, and it's
 303     # too annoying to try to slide it in after the alignment psuedo-op, so
 304     # we take the low road and just emit a dummy OP_NOP here.
 305     if need_dummy_start:
 306         emitAlign()
 307         asm_fp.write(label_prefix + "_OP_NOP:   /* dummy */\n");
 308
 309     emitAlign()
 310     asm_fp.write("    .size   %s, .-%s\n" % (start_label, start_label))
 311     asm_fp.write("    .global %s\n" % end_label)
 312     asm_fp.write("%s:\n" % end_label)
 313
 314     if style == "computed-goto":
 315         emitSectionComment("Sister implementations", asm_fp)
 316         asm_fp.write("    .global dvmAsmSisterStart\n")
 317         asm_fp.write("    .type   dvmAsmSisterStart, %function\n")
 318         asm_fp.write("    .text\n")
 319         asm_fp.write("    .balign 4\n")
 320         asm_fp.write("dvmAsmSisterStart:\n")
 321         asm_fp.writelines(sister_list)
 322         asm_fp.write("\n    .size   dvmAsmSisterStart, .-dvmAsmSisterStart\n")
 323         asm_fp.write("    .global dvmAsmSisterEnd\n")
 324         asm_fp.write("dvmAsmSisterEnd:\n\n")
 325
 326 #
 327 # Load an alternate entry stub
 328 #
 329 def loadAndEmitAltStub(source, opindex):
 330     op = opcodes[opindex]
 331     if verbose:
 332         print " alt emit %s --> stub" % source
 333     dict = getGlobalSubDict()
 334     dict.update({ "opcode":op, "opnum":opindex })
 335
 336     emitAsmHeader(asm_fp, dict, alt_label_prefix)
 337     appendSourceFile(source, dict, asm_fp, None)
 338
 339 #
 340 # Load and emit alternate opcodes for all kNumPackedOpcodes instructions.
 341 #
 342 def loadAndEmitAltOpcodes():
 343     assert len(opcodes) == kNumPackedOpcodes
 344     if style == "jump-table":
 345         start_label = "dvmAsmAltInstructionStartCode"
 346         end_label = "dvmAsmAltInstructionEndCode"
 347     else:
 348         start_label = "dvmAsmAltInstructionStart"
 349         end_label = "dvmAsmAltInstructionEnd"
 350
 351     # point dvmAsmInstructionStart at the first handler or stub
 352     asm_fp.write("\n    .global %s\n" % start_label)
 353     asm_fp.write("    .type   %s, %%function\n" % start_label)
 354     asm_fp.write("    .text\n\n")
 355     asm_fp.write("%s = " % start_label + label_prefix + "_ALT_OP_NOP\n")
 356
 357     for i in xrange(kNumPackedOpcodes):
 358         op = opcodes[i]
 359         if alt_opcode_locations.has_key(op):
 360             source = "%s/ALT_%s.S" % (alt_opcode_locations[op], op)
 361         else:
 362             source = default_alt_stub
 363         loadAndEmitAltStub(source, i)
 364
 365     emitAlign()
 366     asm_fp.write("    .size   %s, .-%s\n" % (start_label, start_label))
 367     asm_fp.write("    .global %s\n" % end_label)
 368     asm_fp.write("%s:\n" % end_label)
 369
 370 #
 371 # Load a C fragment and emit it, then output an assembly stub.
 372 #
 373 def loadAndEmitC(location, opindex):
 374     op = opcodes[opindex]
 375     source = "%s/%s.cpp" % (location, op)
 376     if verbose:
 377         print " emit %s --> C++" % source
 378     dict = getGlobalSubDict()
 379     dict.update({ "opcode":op, "opnum":opindex })
 380
 381     appendSourceFile(source, dict, c_fp, None)
 382
 383     if len(asm_stub_text) != 0:
 384         emitAsmStub(asm_fp, dict)
 385
 386 #
 387 # Load an assembly fragment and emit it.
 388 #
 389 def loadAndEmitAsm(location, opindex, sister_list):
 390     op = opcodes[opindex]
 391     source = "%s/%s.S" % (location, op)
 392     dict = getGlobalSubDict()
 393     dict.update({ "opcode":op, "opnum":opindex })
 394     if verbose:
 395         print " emit %s --> asm" % source
 396
 397     emitAsmHeader(asm_fp, dict, label_prefix)
 398     appendSourceFile(source, dict, asm_fp, sister_list)
 399
 400 #
 401 # Output the alignment directive and label for an assembly piece.
 402 #
 403 def emitAsmHeader(outfp, dict, prefix):
 404     outfp.write("/* ------------------------------ */\n")
 405     # The alignment directive ensures that the handler occupies
 406     # at least the correct amount of space.  We don't try to deal
 407     # with overflow here.
 408     emitAlign()
 409     # Emit a label so that gdb will say the right thing.  We prepend an
 410     # underscore so the symbol name doesn't clash with the Opcode enum.
 411     outfp.write(prefix + "_%(opcode)s: /* 0x%(opnum)02x */\n" % dict)
 412
 413 #
 414 # Output a generic instruction stub that updates the "glue" struct and
 415 # calls the C implementation.
 416 #
 417 def emitAsmStub(outfp, dict):
 418     emitAsmHeader(outfp, dict, label_prefix)
 419     for line in asm_stub_text:
 420         templ = Template(line)
 421         outfp.write(templ.substitute(dict))
 422
 423 #
 424 # Append the file specified by "source" to the open "outfp".  Each line will
 425 # be template-replaced using the substitution dictionary "dict".
 426 #
 427 # If the first line of the file starts with "%" it is taken as a directive.
 428 # A "%include" line contains a filename and, optionally, a Python-style
 429 # dictionary declaration with substitution strings.  (This is implemented
 430 # with recursion.)
 431 #
 432 # If "sister_list" is provided, and we find a line that contains only "&",
 433 # all subsequent lines from the file will be appended to sister_list instead
 434 # of copied to the output.
 435 #
 436 # This may modify "dict".
 437 #
 438 def appendSourceFile(source, dict, outfp, sister_list):
 439     outfp.write("/* File: %s */\n" % source)
 440     infp = open(source, "r")
 441     in_sister = False
 442     for line in infp:
 443         if line.startswith("%include"):
 444             # Parse the "include" line
 445             tokens = line.strip().split(' ', 2)
 446             if len(tokens) < 2:
 447                 raise DataParseError("malformed %%include in %s" % source)
 448
 449             alt_source = tokens[1].strip("\"")
 450             if alt_source == source:
 451                 raise DataParseError("self-referential %%include in %s"
 452                         % source)
 453
 454             new_dict = dict.copy()
 455             if len(tokens) == 3:
 456                 new_dict.update(eval(tokens[2]))
 457             #print " including src=%s dict=%s" % (alt_source, new_dict)
 458             appendSourceFile(alt_source, new_dict, outfp, sister_list)
 459             continue
 460
 461         elif line.startswith("%default"):
 462             # copy keywords into dictionary
 463             tokens = line.strip().split(' ', 1)
 464             if len(tokens) < 2:
 465                 raise DataParseError("malformed %%default in %s" % source)
 466             defaultValues = eval(tokens[1])
 467             for entry in defaultValues:
 468                 dict.setdefault(entry, defaultValues[entry])
 469             continue
 470
 471         elif line.startswith("%verify"):
 472             # more to come, someday
 473             continue
 474
 475         elif line.startswith("%break") and sister_list != None:
 476             # allow more than one %break, ignoring all following the first
 477             if style == "computed-goto" and not in_sister:
 478                 in_sister = True
 479                 sister_list.append("\n/* continuation for %(opcode)s */\n"%dict)
 480             continue
 481
 482         # perform keyword substitution if a dictionary was provided
 483         if dict != None:
 484             templ = Template(line)
 485             try:
 486                 subline = templ.substitute(dict)
 487             except KeyError, err:
 488                 raise DataParseError("keyword substitution failed in %s: %s"
 489                         % (source, str(err)))
 490             except:
 491                 print "ERROR: substitution failed: " + line
 492                 raise
 493         else:
 494             subline = line
 495
 496         # write output to appropriate file
 497         if in_sister:
 498             sister_list.append(subline)
 499         else:
 500             outfp.write(subline)
 501     outfp.write("\n")
 502     infp.close()
 503
 504 #
 505 # Emit a C-style section header comment.
 506 #
 507 def emitSectionComment(str, fp):
 508     equals = "========================================" \
 509              "==================================="
 510
 511     fp.write("\n/*\n * %s\n *  %s\n * %s\n */\n" %
 512         (equals, str, equals))
 513
 514
 515 #
 516 # ===========================================================================
 517 # "main" code
 518 #
 519
 520 #
 521 # Check args.
 522 #
 523 if len(sys.argv) != 3:
 524     print "Usage: %s target-arch output-dir" % sys.argv[0]
 525     sys.exit(2)
 526
 527 target_arch = sys.argv[1]
 528 output_dir = sys.argv[2]
 529
 530 #
 531 # Extract opcode list.
 532 #
 533 opcodes = getOpcodeList()
 534 #for op in opcodes:
 535 #    print "  %s" % op
 536
 537 #
 538 # Open config file.
 539 #
 540 try:
 541     config_fp = open("config-%s" % target_arch)
 542 except:
 543     print "Unable to open config file 'config-%s'" % target_arch
 544     sys.exit(1)
 545
 546 #
 547 # Open and prepare output files.
 548 #
 549 try:
 550     c_fp = open("%s/InterpC-%s.cpp" % (output_dir, target_arch), "w")
 551     asm_fp = open("%s/InterpAsm-%s.S" % (output_dir, target_arch), "w")
 552 except:
 553     print "Unable to open output files"
 554     print "Make sure directory '%s' exists and existing files are writable" \
 555             % output_dir
 556     # Ideally we'd remove the files to avoid confusing "make", but if they
 557     # failed to open we probably won't be able to remove them either.
 558     sys.exit(1)
 559
 560 print "Generating %s, %s" % (c_fp.name, asm_fp.name)
 561
 562 file_header = """/*
 563  * This file was generated automatically by gen-mterp.py for '%s'.
 564  *
 565  * --> DO NOT EDIT <--
 566  */
 567
 568 """ % (target_arch)
 569
 570 c_fp.write(file_header)
 571 asm_fp.write(file_header)
 572
 573 #
 574 # Process the config file.
 575 #
 576 failed = False
 577 try:
 578     for line in config_fp:
 579         line = line.strip()         # remove CRLF, leading spaces
 580         tokens = line.split(' ')    # tokenize
 581         #print "%d: %s" % (len(tokens), tokens)
 582         if len(tokens[0]) == 0:
 583             #print "  blank"
 584             pass
 585         elif tokens[0][0] == '#':
 586             #print "  comment"
 587             pass
 588         else:
 589             if tokens[0] == "handler-size":
 590                 setHandlerSize(tokens)
 591             elif tokens[0] == "import":
 592                 importFile(tokens)
 593             elif tokens[0] == "asm-stub":
 594                 setAsmStub(tokens)
 595             elif tokens[0] == "asm-alt-stub":
 596                 setAsmAltStub(tokens)
 597             elif tokens[0] == "op-start":
 598                 opStart(tokens)
 599             elif tokens[0] == "op-end":
 600                 opEnd(tokens)
 601             elif tokens[0] == "alt":
 602                 altEntry(tokens)
 603             elif tokens[0] == "op":
 604                 opEntry(tokens)
 605             elif tokens[0] == "handler-style":
 606                 setHandlerStyle(tokens)
 607             elif tokens[0] == "alt-ops":
 608                 genaltop(tokens)
 609             elif tokens[0] == "split-ops":
 610                 splitops = True
 611             else:
 612                 raise DataParseError, "unrecognized command '%s'" % tokens[0]
 613             if style == None:
 614                 print "tokens[0] = %s" % tokens[0]
 615                 raise DataParseError, "handler-style must be first command"
 616 except DataParseError, err:
 617     print "Failed: " + str(err)
 618     # TODO: remove output files so "make" doesn't get confused
 619     failed = True
 620     c_fp.close()
 621     asm_fp.close()
 622     c_fp = asm_fp = None
 623
 624 config_fp.close()
 625
 626 #
 627 # Done!
 628 #
 629 if c_fp:
 630     c_fp.close()
 631 if asm_fp:
 632     asm_fp.close()
 633
 634 sys.exit(failed)