1 /*
   2  * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 package sun.jvm.hotspot.ui.classbrowser;
  26 
  27 import java.io.*;
  28 import java.util.*;
  29 import sun.jvm.hotspot.asm.*;
  30 import sun.jvm.hotspot.code.*;
  31 import sun.jvm.hotspot.compiler.*;
  32 import sun.jvm.hotspot.debugger.*;
  33 import sun.jvm.hotspot.interpreter.*;
  34 import sun.jvm.hotspot.oops.*;
  35 import sun.jvm.hotspot.runtime.*;
  36 import sun.jvm.hotspot.tools.jcore.*;
  37 import sun.jvm.hotspot.utilities.*;
  38 
  39 public class HTMLGenerator implements /* imports */ ClassConstants {
  40     static class Formatter {
  41         boolean html;
  42         StringBuffer buf = new StringBuffer();
  43 
  44         Formatter(boolean h) {
  45             html = h;
  46         }
  47 
  48         void append(String s) {
  49             buf.append(s);
  50         }
  51 
  52         void append(int s) {
  53             buf.append(s);
  54         }
  55 
  56         void append(char s) {
  57             buf.append(s);
  58         }
  59 
  60         void append(StringBuffer s) {
  61             buf.append(s);
  62         }
  63 
  64         void append(Formatter s) {
  65             buf.append(s);
  66         }
  67 
  68         StringBuffer getBuffer() {
  69             return buf;
  70         }
  71 
  72         public String toString() {
  73             return buf.toString();
  74         }
  75 
  76         void wrap(String tag, String text) {
  77             wrap(tag, tag, text);
  78         }
  79         void wrap(String before, String after, String text) {
  80             beginTag(before);
  81             append(text);
  82             endTag(after);
  83         }
  84 
  85         // header tags
  86         void h1(String s) { nl(); wrap("h1", s); nl(); }
  87         void h2(String s) { nl(); wrap("h2", s); nl(); }
  88         void h3(String s) { nl(); wrap("h3", s); nl(); }
  89         void h4(String s) { nl(); wrap("h4", s); nl(); }
  90 
  91         // list tags
  92         void beginList()  { beginTag("ul"); nl(); }
  93         void endList()    { endTag("ul"); nl();   }
  94         void beginListItem() { beginTag("li"); }
  95         void endListItem()   { endTag("li"); nl();   }
  96         void li(String s) { wrap("li", s); nl();  }
  97 
  98         // table tags
  99         void beginTable(int border) {
 100             beginTag("table border='" + border + "'");
 101         }
 102         void cell(String s) { wrap("td", s); }
 103         void headerCell(String s) { wrap("th", s); }
 104         void endTable() { endTag("table"); }
 105 
 106         void link(String href, String text) {
 107             wrap("a href='" + href + "'", "a", text);
 108         }
 109         void beginTag(String s) {
 110             if (html) { append("<"); append(s); append(">"); }
 111         }
 112         void endTag(String s) {
 113             if (html) {
 114                append("</"); append(s); append(">");
 115             } else {
 116                if (s.equals("table") || s.equals("tr")) {
 117                   nl();
 118                }
 119                if (s.equals("td") || s.equals("th")) {
 120                   append(" ");
 121                }
 122             }
 123         }
 124         void bold(String s) {
 125             wrap("b", s);
 126         }
 127 
 128         void nl() {
 129             if (!html) buf.append("\n");
 130         }
 131 
 132         void br() {
 133             if (html) append("<br>");
 134             else      append("\n");
 135         }
 136         void genEmptyHTML() {
 137             if (html) append("<html></html>");
 138         }
 139 
 140         void genHTMLPrologue() {
 141             if (html) append("<html><body>");
 142         }
 143 
 144         void genHTMLPrologue(String title) {
 145             if (html) {
 146                 append("<html><head><title>");
 147                 append(title);
 148                 append("</title></head>");
 149                 append("<body>");
 150             }
 151             h2(title);
 152         }
 153         void genHTMLEpilogue() {
 154             if (html) append("</body></html>");
 155         }
 156 
 157     }
 158 
 159    private static final String DUMP_KLASS_OUTPUT_DIR = ".";
 160    private static final int NATIVE_CODE_SIZE = 200;
 161    private final String spaces;
 162    private final String tab;
 163 
 164    private boolean genHTML = true;
 165 
 166    public HTMLGenerator() {
 167        this(true);
 168    }
 169 
 170    public HTMLGenerator(boolean html) {
 171        genHTML = html;
 172        if (html) {
 173            spaces = "&nbsp;&nbsp;";
 174            tab = "&nbsp;&nbsp;&nbsp;&nbsp;";
 175        } else {
 176            spaces = "  ";
 177            tab = "    ";
 178        }
 179    }
 180 
 181    protected String escapeHTMLSpecialChars(String value) {
 182       if (!genHTML) return value;
 183 
 184       Formatter buf = new Formatter(genHTML);
 185       int len = value.length();
 186       for (int i=0; i < len; i++) {
 187          char c = value.charAt(i);
 188          switch (c) {
 189             case '<':
 190                buf.append("&lt;");
 191                break;
 192             case '>':
 193                buf.append("&gt;");
 194                break;
 195             case '&':
 196                buf.append("&amp;");
 197                break;
 198             default:
 199                buf.append(c);
 200                break;
 201          }
 202       }
 203       return buf.toString();
 204    }
 205 
 206    public String genHTMLForMessage(String message) {
 207       Formatter buf = new Formatter(genHTML);
 208       buf.genHTMLPrologue(message);
 209       buf.genHTMLEpilogue();
 210       return buf.toString();
 211    }
 212 
 213    public String genHTMLErrorMessage(Exception exp) {
 214       exp.printStackTrace();
 215       return genHTMLForMessage(exp.getClass().getName() + " : " + exp.getMessage());
 216    }
 217 
 218    public String genHTMLForWait(String message) {
 219       Formatter buf = new Formatter(genHTML);
 220       buf.genHTMLPrologue("Please wait ..");
 221       buf.h2(message);
 222       return buf.toString();
 223    }
 224 
 225    protected String genKlassTitle(InstanceKlass klass) {
 226       Formatter buf = new Formatter(genHTML);
 227       AccessFlags acc = klass.getAccessFlagsObj();
 228       if (acc.isPublic()) {
 229          buf.append("public ");
 230       } else if (acc.isProtected()) {
 231          buf.append("protected ");
 232       } else if (acc.isPrivate()) {
 233          buf.append("private ");
 234       }
 235 
 236       if (acc.isStatic()) {
 237          buf.append("static ");
 238       }
 239 
 240       if (acc.isAbstract() ) {
 241          buf.append("abstract ");
 242       } else if (acc.isFinal()) {
 243          buf.append("final ");
 244       }
 245 
 246       if (acc.isStrict()) {
 247          buf.append("strict ");
 248       }
 249 
 250       // javac generated flags
 251       if (acc.isEnum()) {
 252          buf.append("[enum] ");
 253       }
 254       if (acc.isSynthetic()) {
 255          buf.append("[synthetic] ");
 256       }
 257 
 258       if (klass.isInterface()) {
 259          buf.append("interface");
 260       } else {
 261          buf.append("class");
 262       }
 263 
 264       buf.append(' ');
 265       buf.append(klass.getName().asString().replace('/', '.'));
 266       // is it generic?
 267       Symbol genSig = klass.getGenericSignature();
 268       if (genSig != null) {
 269          buf.append(" [signature ");
 270          buf.append(escapeHTMLSpecialChars(genSig.asString()));
 271          buf.append("] ");
 272       } else {
 273          buf.append(' ');
 274       }
 275       buf.append('@');
 276       buf.append(klass.getAddress().toString());
 277       return buf.toString();
 278    }
 279 
 280    protected String genBaseHref() {
 281       return "";
 282    }
 283 
 284    protected String genKlassHref(InstanceKlass klass) {
 285       return genBaseHref() + "klass=" + klass.getAddress();
 286    }
 287 
 288    protected String genKlassLink(InstanceKlass klass) {
 289       Formatter buf = new Formatter(genHTML);
 290       buf.link(genKlassHref(klass), genKlassTitle(klass));
 291       return buf.toString();
 292    }
 293 
 294    protected String genMethodModifierString(AccessFlags acc) {
 295       Formatter buf = new Formatter(genHTML);
 296       if (acc.isPrivate()) {
 297          buf.append("private ");
 298       } else if (acc.isProtected()) {
 299          buf.append("protected ");
 300       } else if (acc.isPublic()) {
 301          buf.append("public ");
 302       }
 303 
 304       if (acc.isStatic()) {
 305          buf.append("static ");
 306       } else if (acc.isAbstract() ) {
 307          buf.append("abstract ");
 308       } else if (acc.isFinal()) {
 309          buf.append("final ");
 310       }
 311 
 312        if (acc.isNative()) {
 313          buf.append("native ");
 314       }
 315 
 316       if (acc.isStrict()) {
 317          buf.append("strict ");
 318       }
 319 
 320       if (acc.isSynchronized()) {
 321          buf.append("synchronized ");
 322       }
 323 
 324       // javac generated flags
 325       if (acc.isBridge()) {
 326          buf.append("[bridge] ");
 327       }
 328 
 329       if (acc.isSynthetic()) {
 330          buf.append("[synthetic] ");
 331       }
 332 
 333       if (acc.isVarArgs()) {
 334          buf.append("[varargs] ");
 335       }
 336 
 337       return buf.toString();
 338    }
 339 
 340    protected String genMethodNameAndSignature(Method method) {
 341       Formatter buf = new Formatter(genHTML);
 342       buf.append(genMethodModifierString(method.getAccessFlagsObj()));
 343       Symbol sig = method.getSignature();
 344       new SignatureConverter(sig, buf.getBuffer()).iterateReturntype();
 345       buf.append(" ");
 346       String methodName = method.getName().asString();
 347       buf.append(escapeHTMLSpecialChars(methodName));
 348       buf.append('(');
 349       new SignatureConverter(sig, buf.getBuffer()).iterateParameters();
 350       buf.append(')');
 351       // is it generic?
 352       Symbol genSig = method.getGenericSignature();
 353       if (genSig != null) {
 354          buf.append(" [signature ");
 355          buf.append(escapeHTMLSpecialChars(genSig.asString()));
 356          buf.append("] ");
 357       }
 358       return buf.toString().replace('/', '.');
 359    }
 360 
 361    protected String genMethodTitle(Method method) {
 362       Formatter buf = new Formatter(genHTML);
 363       buf.append(genMethodNameAndSignature(method));
 364       buf.append(' ');
 365       buf.append('@');
 366       buf.append(method.getAddress().toString());
 367       return buf.toString();
 368    }
 369 
 370    protected String genMethodHref(Method m) {
 371       return genBaseHref() + "method=" + m.getAddress();
 372    }
 373 
 374    protected String genMethodLink(Method m) {
 375       Formatter buf = new Formatter(genHTML);
 376       buf.link(genMethodHref(m), genMethodTitle(m));
 377       return buf.toString();
 378    }
 379 
 380    protected String genMethodAndKlassLink(Method m) {
 381       Formatter buf = new Formatter(genHTML);
 382       buf.append(genMethodLink(m));
 383       buf.append(" of ");
 384       buf.append(genKlassLink((InstanceKlass) m.getMethodHolder()));
 385       return buf.toString();
 386    }
 387 
 388    protected String genNMethodHref(NMethod nm) {
 389       return genBaseHref() + "nmethod=" + nm.getAddress();
 390    }
 391 
 392    public String genNMethodTitle(NMethod nmethod) {
 393       Formatter buf = new Formatter(genHTML);
 394       Method m = nmethod.getMethod();
 395 
 396       buf.append("Disassembly for compiled method [");
 397       buf.append(genMethodTitle(m));
 398       buf.append(" ] ");
 399       buf.append('@');
 400       buf.append(nmethod.getAddress().toString());
 401       return buf.toString();
 402    }
 403 
 404    protected String genNMethodLink(NMethod nm) {
 405       Formatter buf = new Formatter(genHTML);
 406       buf.link(genNMethodHref(nm), genNMethodTitle(nm));
 407       return buf.toString();
 408    }
 409 
 410    public String genCodeBlobTitle(CodeBlob blob) {
 411       Formatter buf = new Formatter(genHTML);
 412       buf.append("Disassembly for code blob " + blob.getName() + " [");
 413       buf.append(blob.getClass().getName());
 414       buf.append(" ] @");
 415       buf.append(blob.getAddress().toString());
 416       return buf.toString();
 417    }
 418 
 419    protected BytecodeDisassembler createBytecodeDisassembler(Method m) {
 420       return new BytecodeDisassembler(m);
 421    }
 422 
 423    private String genLowHighShort(int val) {
 424       Formatter buf = new Formatter(genHTML);
 425       buf.append('#');
 426       buf.append(Integer.toString(val & 0xFFFF));
 427       buf.append(" #");
 428       buf.append(Integer.toString((val >> 16) & 0xFFFF));
 429       return buf.toString();
 430    }
 431 
 432    private String genListOfShort(short[] values) {
 433       if (values == null || values.length == 0)  return "";
 434       Formatter buf = new Formatter(genHTML);
 435       buf.append('[');
 436       for (int i = 0; i < values.length; i++) {
 437           if (i > 0)  buf.append(' ');
 438           buf.append('#');
 439           buf.append(Integer.toString(values[i]));
 440       }
 441       buf.append(']');
 442       return buf.toString();
 443    }
 444 
 445    protected String genHTMLTableForConstantPool(ConstantPool cpool) {
 446       Formatter buf = new Formatter(genHTML);
 447       buf.beginTable(1);
 448 
 449       buf.beginTag("tr");
 450       buf.headerCell("Index");
 451       buf.headerCell("Constant Type");
 452       buf.headerCell("Constant Value");
 453       buf.endTag("tr");
 454 
 455       final int length = (int) cpool.getLength();
 456       // zero'th pool entry is always invalid. ignore it.
 457       for (int index = 1; index < length; index++) {
 458          buf.beginTag("tr");
 459          buf.cell(Integer.toString(index));
 460 
 461          int ctag = (int) cpool.getTags().at((int) index);
 462          switch (ctag) {
 463             case JVM_CONSTANT_Integer:
 464                buf.cell("JVM_CONSTANT_Integer");
 465                buf.cell(Integer.toString(cpool.getIntAt(index)));
 466                break;
 467 
 468             case JVM_CONSTANT_Float:
 469                buf.cell("JVM_CONSTANT_Float");
 470                buf.cell(Float.toString(cpool.getFloatAt(index)));
 471                break;
 472 
 473             case JVM_CONSTANT_Long:
 474                buf.cell("JVM_CONSTANT_Long");
 475                buf.cell(Long.toString(cpool.getLongAt(index)));
 476                // long entries occupy two slots
 477                index++;
 478                break;
 479 
 480             case JVM_CONSTANT_Double:
 481                buf.cell("JVM_CONSTANT_Double");
 482                buf.cell(Double.toString(cpool.getDoubleAt(index)));
 483                // double entries occupy two slots
 484                index++;
 485                break;
 486 
 487             case JVM_CONSTANT_UnresolvedClass:
 488                buf.cell("JVM_CONSTANT_UnresolvedClass");
 489                buf.cell(cpool.getKlassNameAt(index).asString());
 490                break;
 491 
 492             case JVM_CONSTANT_UnresolvedClassInError:
 493                buf.cell("JVM_CONSTANT_UnresolvedClassInError");
 494                buf.cell(cpool.getSymbolAt(index).asString());
 495                break;
 496 
 497             case JVM_CONSTANT_Class:
 498                buf.cell("JVM_CONSTANT_Class");
 499                Klass klass = (Klass) cpool.getKlassAt(index);
 500                if (klass instanceof InstanceKlass) {
 501                   buf.cell(genKlassLink((InstanceKlass) klass));
 502                } else {
 503                   buf.cell(klass.getName().asString().replace('/', '.'));
 504                }
 505                break;
 506 
 507             case JVM_CONSTANT_Utf8:
 508                buf.cell("JVM_CONSTANT_Utf8");
 509                buf.cell("\"" +
 510                  escapeHTMLSpecialChars(cpool.getSymbolAt(index).asString()) +
 511                  "\"");
 512                break;
 513 
 514             case JVM_CONSTANT_String:
 515                buf.cell("JVM_CONSTANT_String");
 516                buf.cell("\"" +
 517                         escapeHTMLSpecialChars(cpool.getUnresolvedStringAt(index).asString()) + "\"");
 518                break;
 519 
 520             case JVM_CONSTANT_Fieldref:
 521                buf.cell("JVM_CONSTANT_Fieldref");
 522                buf.cell(genLowHighShort(cpool.getIntAt(index)));
 523                break;
 524 
 525             case JVM_CONSTANT_Methodref:
 526                buf.cell("JVM_CONSTANT_Methodref");
 527                buf.cell(genLowHighShort(cpool.getIntAt(index)));
 528                break;
 529 
 530             case JVM_CONSTANT_InterfaceMethodref:
 531                buf.cell("JVM_CONSTANT_InterfaceMethodref");
 532                buf.cell(genLowHighShort(cpool.getIntAt(index)));
 533                break;
 534 
 535             case JVM_CONSTANT_NameAndType:
 536                buf.cell("JVM_CONSTANT_NameAndType");
 537                buf.cell(genLowHighShort(cpool.getIntAt(index)));
 538                break;
 539 
 540             case JVM_CONSTANT_ClassIndex:
 541                buf.cell("JVM_CONSTANT_ClassIndex");
 542                buf.cell(Integer.toString(cpool.getIntAt(index)));
 543                break;
 544 
 545             case JVM_CONSTANT_StringIndex:
 546                buf.cell("JVM_CONSTANT_StringIndex");
 547                buf.cell(Integer.toString(cpool.getIntAt(index)));
 548                break;
 549 
 550             case JVM_CONSTANT_MethodHandle:
 551                buf.cell("JVM_CONSTANT_MethodHandle");
 552                buf.cell(genLowHighShort(cpool.getIntAt(index)));
 553                break;
 554 
 555             case JVM_CONSTANT_MethodType:
 556                buf.cell("JVM_CONSTANT_MethodType");
 557                buf.cell(Integer.toString(cpool.getIntAt(index)));
 558                break;
 559 
 560             case JVM_CONSTANT_InvokeDynamic:
 561                buf.cell("JVM_CONSTANT_InvokeDynamic");
 562                buf.cell(genLowHighShort(cpool.getIntAt(index)) +
 563                         genListOfShort(cpool.getBootstrapSpecifierAt(index)));
 564                break;
 565 
 566             default:
 567                throw new InternalError("unknown tag: " + ctag);
 568          }
 569 
 570          buf.endTag("tr");
 571       }
 572 
 573       buf.endTable();
 574       return buf.toString();
 575    }
 576 
 577    public String genHTML(ConstantPool cpool) {
 578       try {
 579          Formatter buf = new Formatter(genHTML);
 580          buf.genHTMLPrologue(genConstantPoolTitle(cpool));
 581          buf.h3("Holder Class");
 582          buf.append(genKlassLink((InstanceKlass) cpool.getPoolHolder()));
 583          buf.h3("Constants");
 584          buf.append(genHTMLTableForConstantPool(cpool));
 585          buf.genHTMLEpilogue();
 586          return buf.toString();
 587       } catch (Exception exp) {
 588          return genHTMLErrorMessage(exp);
 589       }
 590    }
 591 
 592    protected String genConstantPoolHref(ConstantPool cpool) {
 593       return genBaseHref() + "cpool=" + cpool.getAddress();
 594    }
 595 
 596    protected String genConstantPoolTitle(ConstantPool cpool) {
 597       Formatter buf = new Formatter(genHTML);
 598       buf.append("Constant Pool of [");
 599       buf.append(genKlassTitle((InstanceKlass) cpool.getPoolHolder()));
 600       buf.append("] @");
 601       buf.append(cpool.getAddress().toString());
 602       return buf.toString();
 603    }
 604 
 605    protected String genConstantPoolLink(ConstantPool cpool) {
 606       Formatter buf = new Formatter(genHTML);
 607       buf.link(genConstantPoolHref(cpool), genConstantPoolTitle(cpool));
 608       return buf.toString();
 609    }
 610 
 611    public String genHTML(Method method) {
 612       try {
 613          final Formatter buf = new Formatter(genHTML);
 614          buf.genHTMLPrologue(genMethodTitle(method));
 615 
 616          buf.h3("Holder Class");
 617          buf.append(genKlassLink((InstanceKlass) method.getMethodHolder()));
 618 
 619          NMethod nmethod = method.getNativeMethod();
 620          if (nmethod != null) {
 621             buf.h3("Compiled Code");
 622             buf.append(genNMethodLink(nmethod));
 623          }
 624 
 625          boolean hasThrows = method.hasCheckedExceptions();
 626          ConstantPool cpool = ((InstanceKlass) method.getMethodHolder()).getConstants();
 627          if (hasThrows) {
 628             buf.h3("Checked Exception(s)");
 629             CheckedExceptionElement[] exceptions = method.getCheckedExceptions();
 630             buf.beginTag("ul");
 631             for (int exp = 0; exp < exceptions.length; exp++) {
 632                short cpIndex = (short) exceptions[exp].getClassCPIndex();
 633                ConstantPool.CPSlot obj = cpool.getSlotAt(cpIndex);
 634                if (obj.isUnresolved()) {
 635                  buf.li((obj.getSymbol()).asString().replace('/', '.'));
 636                } else {
 637                  buf.li(genKlassLink((InstanceKlass)obj.getKlass()));
 638                }
 639             }
 640             buf.endTag("ul");
 641          }
 642 
 643          if (method.isNative() || method.isAbstract()) {
 644            buf.genHTMLEpilogue();
 645            return buf.toString();
 646          }
 647 
 648          buf.h3("Bytecode");
 649          BytecodeDisassembler disasm = createBytecodeDisassembler(method);
 650          final boolean hasLineNumbers = method.hasLineNumberTable();
 651          disasm.decode(new BytecodeVisitor() {
 652                           private Method method;
 653                           public void prologue(Method m) {
 654                              method = m;
 655                              buf.beginTable(0);
 656                              buf.beginTag("tr");
 657                              if (hasLineNumbers) {
 658                                 buf.headerCell("line");
 659                              }
 660                              buf.headerCell("bci" + spaces);
 661                              buf.headerCell("bytecode");
 662                              buf.endTag("tr");
 663                           }
 664 
 665                           public void visit(Bytecode instr) {
 666                              int curBci = instr.bci();
 667                              buf.beginTag("tr");
 668                              if (hasLineNumbers) {
 669                                 int lineNumber = method.getLineNumberFromBCI(curBci);
 670                                 buf.cell(Integer.toString(lineNumber) + spaces);
 671                              }
 672                              buf.cell(Integer.toString(curBci) + spaces);
 673 
 674                              buf.beginTag("td");
 675                              String instrStr = null;
 676                              try {
 677                                  instrStr = escapeHTMLSpecialChars(instr.toString());
 678                              } catch (RuntimeException re) {
 679                                  buf.append("exception while printing " + instr.getBytecodeName());
 680                                  buf.endTag("td");
 681                                  buf.endTag("tr");
 682                                  re.printStackTrace();
 683                                  return;
 684                              }
 685 
 686                              if (instr instanceof BytecodeNew) {
 687                                 BytecodeNew newBytecode = (BytecodeNew) instr;
 688                                 InstanceKlass klass = newBytecode.getNewKlass();
 689                                 if (klass != null) {
 690                                     buf.link(genKlassHref(klass), instrStr);
 691                                 } else {
 692                                     buf.append(instrStr);
 693                                 }
 694                              } else if(instr instanceof BytecodeInvoke) {
 695                                 BytecodeInvoke invokeBytecode = (BytecodeInvoke) instr;
 696                                 Method m = invokeBytecode.getInvokedMethod();
 697                                 if (m != null) {
 698                                    buf.link(genMethodHref(m), instrStr);
 699                                    buf.append(" of ");
 700                                    InstanceKlass klass = (InstanceKlass) m.getMethodHolder();
 701                                    buf.link(genKlassHref(klass), genKlassTitle(klass));
 702                                 } else {
 703                                    buf.append(instrStr);
 704                                 }
 705                              } else if (instr instanceof BytecodeGetPut) {
 706                                 BytecodeGetPut getPut = (BytecodeGetPut) instr;
 707                                 sun.jvm.hotspot.oops.Field f = getPut.getField();
 708                                 buf.append(instrStr);
 709                                 if (f != null) {
 710                                    InstanceKlass klass = f.getFieldHolder();
 711                                    buf.append(" of ");
 712                                    buf.link(genKlassHref(klass), genKlassTitle(klass));
 713                                 }
 714                              } else if (instr instanceof BytecodeLoadConstant) {
 715                                 BytecodeLoadConstant ldc = (BytecodeLoadConstant) instr;
 716                                 if (ldc.isKlassConstant()) {
 717                                    Object oop = ldc.getKlass();
 718                                    if (oop instanceof InstanceKlass) {
 719                                       buf.append("<a href='");
 720                                       buf.append(genKlassHref((InstanceKlass) oop));
 721                                       buf.append("'>");
 722                                       buf.append(instrStr);
 723                                       buf.append("</a>");
 724                                    } else {
 725                                       // unresolved klass literal
 726                                       buf.append(instrStr);
 727                                    }
 728                                 } else {
 729                                    // not a klass literal
 730                                    buf.append(instrStr);
 731                                 }
 732                              } else {
 733                                 buf.append(instrStr);
 734                              }
 735                              buf.endTag("td");
 736                              buf.endTag("tr");
 737                           }
 738 
 739                           public void epilogue() {
 740                              buf.endTable();
 741                           }
 742                        });
 743 
 744          // display exception table for this method
 745          boolean hasException = method.hasExceptionTable();
 746          if (hasException) {
 747             ExceptionTableElement[] exceptionTable = method.getExceptionTable();
 748             int numEntries = exceptionTable.length;
 749             if (numEntries != 0) {
 750                buf.h4("Exception Table");
 751                buf.beginTable(1);
 752                buf.beginTag("tr");
 753                buf.headerCell("start bci");
 754                buf.headerCell("end bci");
 755                buf.headerCell("handler bci");
 756                buf.headerCell("catch type");
 757                buf.endTag("tr");
 758 
 759                for (int e = 0; e < numEntries; e ++) {
 760                   buf.beginTag("tr");
 761                   buf.cell(Integer.toString(exceptionTable[e].getStartPC()));
 762                   buf.cell(Integer.toString(exceptionTable[e].getEndPC()));
 763                   buf.cell(Integer.toString(exceptionTable[e].getHandlerPC()));
 764                   short cpIndex = (short) exceptionTable[e].getCatchTypeIndex();
 765                   ConstantPool.CPSlot obj = cpIndex == 0? null : cpool.getSlotAt(cpIndex);
 766                   if (obj == null) {
 767                      buf.cell("Any");
 768                   } else if (obj.isUnresolved()) {
 769                      buf.cell(obj.getSymbol().asString().replace('/', '.'));
 770                   } else {
 771                     buf.cell(genKlassLink((InstanceKlass)obj.getKlass()));
 772                   }
 773                   buf.endTag("tr");
 774                }
 775 
 776                buf.endTable();
 777             }
 778          }
 779 
 780          // display constant pool hyperlink
 781          buf.h3("Constant Pool");
 782          buf.append(genConstantPoolLink(cpool));
 783          buf.genHTMLEpilogue();
 784          return buf.toString();
 785       } catch (Exception exp) {
 786          return genHTMLErrorMessage(exp);
 787       }
 788    }
 789 
 790    protected SymbolFinder createSymbolFinder() {
 791       return new DummySymbolFinder();
 792    }
 793 
 794    // genHTML for a given address. Address may be a PC or
 795    // Method* or Klass*.
 796 
 797    public String genHTMLForAddress(String addrStr) {
 798       return genHTML(parseAddress(addrStr));
 799    }
 800 
 801    public String genHTML(sun.jvm.hotspot.debugger.Address pc) {
 802       CodeBlob blob = null;
 803 
 804       try {
 805          blob = (CodeBlob)VM.getVM().getCodeCache().findBlobUnsafe(pc);
 806       } catch (Exception exp) {
 807          // ignore
 808       }
 809 
 810       if (blob != null) {
 811          if (blob instanceof NMethod) {
 812             return genHTML((NMethod)blob);
 813          } else {
 814             // may be interpreter code.
 815             Interpreter interp = VM.getVM().getInterpreter();
 816             if (interp.contains(pc)) {
 817                InterpreterCodelet codelet = interp.getCodeletContaining(pc);
 818                if (codelet == null) {
 819                   return "Unknown location in the Interpreter: " + pc;
 820                }
 821                return genHTML(codelet);
 822             }
 823             return genHTML(blob);
 824          }
 825       } else if (VM.getVM().getCodeCache().contains(pc)) {
 826          return "Unknown location in the CodeCache: " + pc;
 827       }
 828 
 829       // did not find nmethod.
 830       // try Method*, Klass* and ConstantPool*.
 831       try {
 832         Metadata obj = Metadata.instantiateWrapperFor(pc);
 833          if (obj != null) {
 834             if (obj instanceof Method) {
 835                return genHTML((Method) obj);
 836             } else if (obj instanceof InstanceKlass) {
 837                return genHTML((InstanceKlass) obj);
 838             } else if (obj instanceof ConstantPool) {
 839                return genHTML((ConstantPool) obj);
 840             }
 841          }
 842       } catch (Exception exp) {
 843         exp.printStackTrace();
 844          // ignore
 845       }
 846 
 847       // didn't find any. do raw disassembly.
 848       return genHTMLForRawDisassembly(pc, null);
 849    }
 850 
 851    public String genHTMLForRawDisassembly(sun.jvm.hotspot.debugger.Address startPc, int size) {
 852       try {
 853          return genHTMLForRawDisassembly(startPc, size, null);
 854       } catch (Exception exp) {
 855          return genHTMLErrorMessage(exp);
 856       }
 857    }
 858 
 859    protected String genHTMLForRawDisassembly(sun.jvm.hotspot.debugger.Address startPc,
 860                                              String prevPCs) {
 861       try {
 862          return genHTMLForRawDisassembly(startPc, NATIVE_CODE_SIZE, prevPCs);
 863       } catch (Exception exp) {
 864          return genHTMLErrorMessage(exp);
 865       }
 866    }
 867 
 868    protected String genPCHref(long targetPc) {
 869       return genBaseHref() + "pc=0x" + Long.toHexString(targetPc);
 870    }
 871 
 872    protected String genMultPCHref(String pcs) {
 873       StringBuffer buf = new StringBuffer(genBaseHref());
 874       buf.append("pc_multiple=");
 875       buf.append(pcs);
 876       return buf.toString();
 877    }
 878 
 879    protected String genPCHref(Address addr) {
 880       return genPCHref(addressToLong(addr));
 881    }
 882 
 883    class HTMLDisassembler implements InstructionVisitor {
 884       private int instrSize = 0;
 885       private Formatter buf;
 886       private SymbolFinder symFinder = createSymbolFinder();
 887       private long pc;
 888       private ImmutableOopMapSet oms;
 889       private CodeBlob blob;
 890       private NMethod nmethod;
 891 
 892       HTMLDisassembler(Formatter buf, CodeBlob blob) {
 893          this.buf = buf;
 894          this.blob = blob;
 895          if (blob != null) {
 896             if (blob instanceof NMethod) {
 897                nmethod = (NMethod)blob;
 898             }
 899             oms = blob.getOopMaps();
 900          }
 901       }
 902 
 903       public int getInstructionSize() {
 904          return  instrSize;
 905       }
 906 
 907       public void prologue() {
 908       }
 909 
 910       public void beginInstruction(long currentPc) {
 911          pc = currentPc;
 912 
 913          sun.jvm.hotspot.debugger.Address adr = longToAddress(pc);
 914          if (nmethod != null) {
 915             if (adr.equals(nmethod.getEntryPoint()))             print("[Entry Point]\n");
 916             if (adr.equals(nmethod.getVerifiedEntryPoint()))     print("[Verified Entry Point]\n");
 917             if (adr.equals(nmethod.exceptionBegin()))            print("[Exception Handler]\n");
 918             if (adr.equals(nmethod.stubBegin()) &&
 919                 !nmethod.stubBegin().equals(nmethod.stubEnd()))  print("[Stub Code]\n");
 920             // if (adr.equals(nmethod.constsBegin()))               print("[Constants]\n");
 921          }
 922 
 923          buf.append(adr.toString());
 924          buf.append(':');
 925          buf.append(tab);
 926       }
 927 
 928       public void printAddress(long address) {
 929          sun.jvm.hotspot.debugger.Address addr = longToAddress(address);
 930          if (VM.getVM().getCodeCache().contains(addr)) {
 931             buf.link(genPCHref(address), addr.toString());
 932          } else {
 933             buf.append(addr.toString());
 934          }
 935       }
 936 
 937       public void print(String s) {
 938          buf.append(s);
 939       }
 940 
 941       public void endInstruction(long endPc) {
 942          instrSize += endPc - pc;
 943          if (genHTML) buf.br();
 944 
 945          if (nmethod != null) {
 946             ScopeDesc sd = nmethod.scope_desc_in(pc, endPc);
 947             if (sd != null) {
 948                buf.br();
 949                buf.append(genSafepointInfo(nmethod, sd));
 950             }
 951          }
 952 
 953          if (oms != null) {
 954             long base = addressToLong(blob.codeBegin());
 955             for (int i = 0, imax = oms.getCount(); i < imax; i++) {
 956                ImmutableOopMapPair pair = oms.getPairAt(i);
 957                long omspc = base + pair.getPC();
 958                if (omspc > pc) {
 959                   if (omspc <= endPc) {
 960                      buf.br();
 961                      buf.append(genOopMapInfo(oms.getMap(pair)));
 962                      // st.move_to(column);
 963                      // visitor.print("; ");
 964                         // om.print_on(st);
 965                   }
 966                   break;
 967                }
 968             }
 969          }
 970          // follow each complete insn by a nice newline
 971          buf.br();
 972       }
 973 
 974       public void epilogue() {
 975       }
 976    };
 977 
 978    protected String genHTMLForRawDisassembly(sun.jvm.hotspot.debugger.Address addr,
 979                                              int size,
 980                                              String prevPCs) {
 981       try {
 982          final Formatter buf = new Formatter(genHTML);
 983          buf.genHTMLPrologue("Disassembly @ " + addr);
 984 
 985          if (prevPCs != null && genHTML) {
 986              buf.beginTag("p");
 987              buf.link(genMultPCHref(prevPCs), "show previous code ..");
 988              buf.endTag("p");
 989          }
 990 
 991 
 992          buf.h3("Code");
 993          HTMLDisassembler visitor = new HTMLDisassembler(buf, null);
 994          Disassembler.decode(visitor, null, addr, addr.addOffsetTo(size));
 995 
 996          if (genHTML) buf.beginTag("p");
 997          Formatter tmpBuf = new Formatter(genHTML);
 998          long startPc = addressToLong(addr);
 999          tmpBuf.append("0x");
1000          tmpBuf.append(Long.toHexString(startPc + visitor.getInstructionSize()).toString());
1001          tmpBuf.append(",0x");
1002          tmpBuf.append(Long.toHexString(startPc));
1003          if (prevPCs != null) {
1004             tmpBuf.append(',');
1005             tmpBuf.append(prevPCs);
1006          }
1007          if (genHTML) {
1008              buf.link(genMultPCHref(tmpBuf.toString()), "show more code ..");
1009              buf.endTag("p");
1010          }
1011 
1012          buf.genHTMLEpilogue();
1013          return buf.toString();
1014       } catch (Exception exp) {
1015          return genHTMLErrorMessage(exp);
1016       }
1017    }
1018 
1019    protected String genSafepointInfo(NMethod nm, ScopeDesc sd) {
1020        Formatter buf = new Formatter(genHTML);
1021        Formatter tabs = new Formatter(genHTML);
1022        tabs.append(tab + tab + tab); // Initial indent for debug info
1023 
1024        buf.beginTag("pre");
1025        genScope(buf, tabs, sd);
1026 
1027        // Reset indent for scalar replaced objects
1028        tabs = new Formatter(genHTML);
1029        tabs.append(tab + tab + tab); // Initial indent for debug info
1030 
1031        genScObjInfo(buf, tabs, sd);
1032        buf.endTag("pre");
1033 
1034        return buf.toString();
1035    }
1036 
1037     protected void genScope(Formatter buf, Formatter tabs, ScopeDesc sd) {
1038         if (sd == null) {
1039             return;
1040         }
1041 
1042         genScope(buf, tabs, sd.sender());
1043 
1044         buf.append(tabs);
1045         Method m = sd.getMethod();
1046         buf.append(genMethodAndKlassLink(m));
1047         int bci = sd.getBCI();
1048         buf.append(" @ bci = ");
1049         buf.append(Integer.toString(bci));
1050 
1051         int line = m.getLineNumberFromBCI(bci);
1052         if (line != -1) {
1053             buf.append(", line = ");
1054             buf.append(Integer.toString(line));
1055         }
1056 
1057         List locals = sd.getLocals();
1058         if (locals != null) {
1059             buf.br();
1060             buf.append(tabs);
1061             buf.append(genHTMLForLocals(sd, locals));
1062         }
1063 
1064         List expressions = sd.getExpressions();
1065         if (expressions != null) {
1066             buf.br();
1067             buf.append(tabs);
1068             buf.append(genHTMLForExpressions(sd, expressions));
1069         }
1070 
1071         List monitors = sd.getMonitors();
1072         if (monitors != null) {
1073             buf.br();
1074             buf.append(tabs);
1075             buf.append(genHTMLForMonitors(sd, monitors));
1076         }
1077 
1078         buf.br();
1079         tabs.append(tab);
1080     }
1081 
1082     protected void genScObjInfo(Formatter buf, Formatter tabs, ScopeDesc sd) {
1083         if (sd == null) {
1084             return;
1085         }
1086 
1087         List objects = sd.getObjects();
1088         if (objects == null) {
1089             return;
1090         }
1091         int length = objects.size();
1092         for (int i = 0; i < length; i++) {
1093             buf.append(tabs);
1094             ObjectValue ov = (ObjectValue)objects.get(i);
1095             buf.append("ScObj" + i);
1096             ScopeValue sv = ov.getKlass();
1097             if (Assert.ASSERTS_ENABLED) {
1098                 Assert.that(sv.isConstantOop(), "scalar replaced object klass must be constant oop");
1099             }
1100             ConstantOopReadValue klv = (ConstantOopReadValue)sv;
1101             OopHandle klHandle = klv.getValue();
1102             if (Assert.ASSERTS_ENABLED) {
1103                 Assert.that(klHandle != null, "scalar replaced object klass must be not NULL");
1104             }
1105             Oop obj = VM.getVM().getObjectHeap().newOop(klHandle);
1106             // Obj is a Java mirror
1107             Klass klass = java_lang_Class.asKlass(obj);
1108             if (klass instanceof InstanceKlass) {
1109                 InstanceKlass kls = (InstanceKlass) klass;
1110                 buf.append(" " + kls.getName().asString() + "={");
1111                 int flen = ov.fieldsSize();
1112 
1113                 U2Array klfields = kls.getFields();
1114                 int klen = (int) klfields.length();
1115                 int findex = 0;
1116                 for (int index = 0; index < klen; index++) {
1117                     int accsFlags = kls.getFieldAccessFlags(index);
1118                     Symbol f_name = kls.getFieldName(index);
1119                     AccessFlags access = new AccessFlags(accsFlags);
1120                     if (!access.isStatic()) {
1121                         ScopeValue svf = ov.getFieldAt(findex++);
1122                         String    fstr = scopeValueAsString(sd, svf);
1123                         buf.append(" [" + f_name.asString() + " :"+ index + "]=(#" + fstr + ")");
1124                     }
1125                 }
1126                 buf.append(" }");
1127             } else {
1128                 buf.append(" ");
1129                 int flen = ov.fieldsSize();
1130                 if (klass instanceof TypeArrayKlass) {
1131                     TypeArrayKlass kls = (TypeArrayKlass) klass;
1132                     buf.append(kls.getElementTypeName() + "[" + flen + "]");
1133                 } else if (klass instanceof ObjArrayKlass) {
1134                     ObjArrayKlass kls = (ObjArrayKlass) klass;
1135                     Klass elobj = kls.getBottomKlass();
1136                     if (elobj instanceof InstanceKlass) {
1137                         buf.append(elobj.getName().asString());
1138                     } else if (elobj instanceof TypeArrayKlass) {
1139                         TypeArrayKlass elkls = (TypeArrayKlass) elobj;
1140                         buf.append(elkls.getElementTypeName());
1141                     } else {
1142                         if (Assert.ASSERTS_ENABLED) {
1143                             Assert.that(false, "unknown scalar replaced object klass!");
1144                         }
1145                     }
1146                     buf.append("[" + flen + "]");
1147                     int ndim = (int) kls.getDimension();
1148                     while (--ndim > 0) {
1149                         buf.append("[]");
1150                     }
1151                 } else {
1152                     if (Assert.ASSERTS_ENABLED) {
1153                         Assert.that(false, "unknown scalar replaced object klass!");
1154                     }
1155                 }
1156                 buf.append("={");
1157                 for (int findex = 0; findex < flen; findex++) {
1158                     ScopeValue svf = ov.getFieldAt(findex);
1159                     String fstr = scopeValueAsString(sd, svf);
1160                     buf.append(" [" + findex + "]=(#" + fstr + ")");
1161                 }
1162                 buf.append(" }");
1163             }
1164             buf.br();
1165         }
1166     }
1167 
1168    protected String genHTMLForOopMap(ImmutableOopMap map) {
1169       final int stack0 = VMRegImpl.getStack0().getValue();
1170       Formatter buf = new Formatter(genHTML);
1171 
1172       final class OopMapValueIterator {
1173          final Formatter iterate(OopMapStream oms, String type, boolean printContentReg) {
1174             Formatter tmpBuf = new Formatter(genHTML);
1175             boolean found = false;
1176             tmpBuf.beginTag("tr");
1177             tmpBuf.beginTag("td");
1178             tmpBuf.append(type);
1179             for (; ! oms.isDone(); oms.next()) {
1180                OopMapValue omv = oms.getCurrent();
1181                if (omv == null) {
1182                   continue;
1183                }
1184                found = true;
1185                VMReg vmReg = omv.getReg();
1186                int reg = vmReg.getValue();
1187                if (reg < stack0) {
1188                   tmpBuf.append(VMRegImpl.getRegisterName(reg));
1189                } else {
1190                   tmpBuf.append('[');
1191                   tmpBuf.append(Integer.toString((reg - stack0) * 4));
1192                   tmpBuf.append(']');
1193                }
1194                if (printContentReg) {
1195                   tmpBuf.append(" = ");
1196                   VMReg vmContentReg = omv.getContentReg();
1197                   int contentReg = vmContentReg.getValue();
1198                   if (contentReg < stack0) {
1199                      tmpBuf.append(VMRegImpl.getRegisterName(contentReg));
1200                   } else {
1201                      tmpBuf.append('[');
1202                      tmpBuf.append(Integer.toString((contentReg - stack0) * 4));
1203                      tmpBuf.append(']');
1204                   }
1205                }
1206                tmpBuf.append(spaces);
1207             }
1208             tmpBuf.endTag("td");
1209             tmpBuf.endTag("tr");
1210             return found ? tmpBuf : new Formatter(genHTML);
1211          }
1212       }
1213 
1214       buf.beginTable(0);
1215 
1216       OopMapValueIterator omvIterator = new OopMapValueIterator();
1217       OopMapStream oms = new OopMapStream(map, OopMapValue.OopTypes.OOP_VALUE);
1218       buf.append(omvIterator.iterate(oms, "Oops:", false));
1219 
1220       oms = new OopMapStream(map, OopMapValue.OopTypes.NARROWOOP_VALUE);
1221       buf.append(omvIterator.iterate(oms, "NarrowOops:", false));
1222 
1223       oms = new OopMapStream(map, OopMapValue.OopTypes.CALLEE_SAVED_VALUE);
1224       buf.append(omvIterator.iterate(oms, "Callee saved:",  true));
1225 
1226       oms = new OopMapStream(map, OopMapValue.OopTypes.DERIVED_OOP_VALUE);
1227       buf.append(omvIterator.iterate(oms, "Derived oops:", true));
1228 
1229       buf.endTag("table");
1230       return buf.toString();
1231    }
1232 
1233 
1234    protected String genOopMapInfo(NMethod nmethod, PCDesc pcDesc) {
1235       ImmutableOopMapSet mapSet = nmethod.getOopMaps();
1236       if (mapSet == null || (mapSet.getCount() <= 0))
1237         return "";
1238       int pcOffset = pcDesc.getPCOffset();
1239       ImmutableOopMap map = mapSet.findMapAtOffset(pcOffset, VM.getVM().isDebugging());
1240       if (map == null) {
1241          throw new IllegalArgumentException("no oopmap at safepoint!");
1242       }
1243 
1244       return genOopMapInfo(map);
1245    }
1246 
1247    protected String genOopMapInfo(ImmutableOopMap map) {
1248      Formatter buf = new Formatter(genHTML);
1249      buf.beginTag("pre");
1250      buf.append("OopMap: ");
1251      buf.br();
1252      buf.append(genHTMLForOopMap(map));
1253      buf.endTag("pre");
1254 
1255      return buf.toString();
1256    }
1257 
1258    protected String locationAsString(Location loc) {
1259       Formatter buf = new Formatter(genHTML);
1260       if (loc.isIllegal()) {
1261          buf.append("illegal");
1262       } else {
1263          Location.Where  w  = loc.getWhere();
1264          Location.Type type = loc.getType();
1265 
1266          if (w == Location.Where.ON_STACK) {
1267             buf.append("stack[" + loc.getStackOffset() + "]");
1268          } else if (w == Location.Where.IN_REGISTER) {
1269             boolean isFloat = (type == Location.Type.FLOAT_IN_DBL ||
1270                                type == Location.Type.DBL);
1271             int regNum = loc.getRegisterNumber();
1272             VMReg vmReg = new VMReg(regNum);
1273             buf.append(VMRegImpl.getRegisterName(vmReg.getValue()));
1274          }
1275 
1276          buf.append(", ");
1277          if (type == Location.Type.NORMAL) {
1278             buf.append("normal");
1279          } else if (type == Location.Type.OOP) {
1280             buf.append("oop");
1281          } else if (type == Location.Type.NARROWOOP) {
1282             buf.append("narrowoop");
1283          } else if (type == Location.Type.INT_IN_LONG) {
1284             buf.append("int");
1285          } else if (type == Location.Type.LNG) {
1286             buf.append("long");
1287          } else if (type == Location.Type.FLOAT_IN_DBL) {
1288             buf.append("float");
1289          } else if (type == Location.Type.DBL) {
1290             buf.append("double");
1291          } else if (type == Location.Type.ADDR) {
1292             buf.append("address");
1293          } else if (type == Location.Type.INVALID) {
1294             buf.append("invalid");
1295          }
1296       }
1297       return buf.toString();
1298    }
1299 
1300    private String scopeValueAsString(ScopeDesc sd, ScopeValue sv) {
1301       Formatter buf = new Formatter(genHTML);
1302       if (sv.isConstantInt()) {
1303          buf.append("int ");
1304          ConstantIntValue intValue = (ConstantIntValue) sv;
1305          buf.append(Integer.toString(intValue.getValue()));
1306       } else if (sv.isConstantLong()) {
1307          buf.append("long ");
1308          ConstantLongValue longValue = (ConstantLongValue) sv;
1309          buf.append(Long.toString(longValue.getValue()));
1310          buf.append("L");
1311       } else if (sv.isConstantDouble()) {
1312          buf.append("double ");
1313          ConstantDoubleValue dblValue = (ConstantDoubleValue) sv;
1314          buf.append(Double.toString(dblValue.getValue()));
1315          buf.append("D");
1316       } else if (sv.isConstantOop()) {
1317          buf.append("oop ");
1318          ConstantOopReadValue oopValue = (ConstantOopReadValue) sv;
1319          OopHandle oopHandle = oopValue.getValue();
1320          if (oopHandle != null) {
1321             buf.append(oopHandle.toString());
1322          } else {
1323             buf.append("null");
1324          }
1325       } else if (sv.isLocation()) {
1326          LocationValue lvalue = (LocationValue) sv;
1327          Location loc = lvalue.getLocation();
1328          if (loc != null) {
1329             buf.append(locationAsString(loc));
1330          } else {
1331             buf.append("null");
1332          }
1333       } else if (sv.isObject()) {
1334          ObjectValue ov = (ObjectValue)sv;
1335          buf.append("#ScObj" + sd.getObjects().indexOf(ov));
1336       } else {
1337          buf.append("unknown scope value " + sv);
1338       }
1339       return buf.toString();
1340    }
1341 
1342    protected String genHTMLForScopeValues(ScopeDesc sd, boolean locals, List values) {
1343       int length = values.size();
1344       Formatter buf = new Formatter(genHTML);
1345       buf.append(locals? "locals " : "expressions ");
1346       for (int i = 0; i < length; i++) {
1347          ScopeValue sv = (ScopeValue) values.get(i);
1348          if (sv == null) {
1349             continue;
1350          }
1351          buf.append('(');
1352          if (locals) {
1353             Symbol name = sd.getMethod().getLocalVariableName(sd.getBCI(), i);
1354             if (name != null) {
1355                buf.append("'");
1356                buf.append(name.asString());
1357                buf.append('\'');
1358             } else {
1359                buf.append("[");
1360                buf.append(Integer.toString(i));
1361                buf.append(']');
1362             }
1363          } else {
1364             buf.append("[");
1365             buf.append(Integer.toString(i));
1366             buf.append(']');
1367          }
1368 
1369          buf.append(", ");
1370          buf.append(scopeValueAsString(sd, sv));
1371          buf.append(") ");
1372       }
1373 
1374       return buf.toString();
1375    }
1376 
1377    protected String genHTMLForLocals(ScopeDesc sd, List locals) {
1378       return genHTMLForScopeValues(sd, true, locals);
1379    }
1380 
1381    protected String genHTMLForExpressions(ScopeDesc sd, List expressions) {
1382       return genHTMLForScopeValues(sd, false, expressions);
1383    }
1384 
1385    protected String genHTMLForMonitors(ScopeDesc sd, List monitors) {
1386       int length = monitors.size();
1387       Formatter buf = new Formatter(genHTML);
1388       buf.append("monitors ");
1389       for (int i = 0; i < length; i++) {
1390          MonitorValue mv = (MonitorValue) monitors.get(i);
1391          if (mv == null) {
1392             continue;
1393          }
1394          buf.append("(owner = ");
1395          ScopeValue owner = mv.owner();
1396          if (owner != null) {
1397             buf.append(scopeValueAsString(sd, owner));
1398          } else {
1399             buf.append("null");
1400          }
1401          buf.append(", lock = ");
1402 
1403          Location loc = mv.basicLock();
1404          if (loc != null) {
1405             buf.append(locationAsString(loc));
1406          } else {
1407             buf.append("null");
1408          }
1409          buf.append(") ");
1410       }
1411       return buf.toString();
1412    }
1413 
1414    public String genHTML(final NMethod nmethod) {
1415       try {
1416          final Formatter buf = new Formatter(genHTML);
1417          buf.genHTMLPrologue(genNMethodTitle(nmethod));
1418          buf.h3("Method");
1419          buf.append(genMethodAndKlassLink(nmethod.getMethod()));
1420 
1421          buf.h3("Compiled Code");
1422          Disassembler.decode(new HTMLDisassembler(buf, nmethod), nmethod);
1423          buf.genHTMLEpilogue();
1424          return buf.toString();
1425       } catch (Exception exp) {
1426          return genHTMLErrorMessage(exp);
1427       }
1428    }
1429 
1430   public String genHTML(final CodeBlob blob) {
1431       try {
1432          final Formatter buf = new Formatter(genHTML);
1433          buf.genHTMLPrologue(genCodeBlobTitle(blob));
1434          buf.h3("CodeBlob");
1435 
1436          buf.h3("Compiled Code");
1437          Disassembler.decode(new HTMLDisassembler(buf, blob), blob);
1438 
1439          buf.genHTMLEpilogue();
1440          return buf.toString();
1441       } catch (Exception exp) {
1442          return genHTMLErrorMessage(exp);
1443       }
1444    }
1445 
1446    protected String genInterpreterCodeletTitle(InterpreterCodelet codelet) {
1447       Formatter buf = new Formatter(genHTML);
1448       buf.append("Interpreter codelet [");
1449       buf.append(codelet.codeBegin().toString());
1450       buf.append(',');
1451       buf.append(codelet.codeEnd().toString());
1452       buf.append(") - ");
1453       buf.append(codelet.getDescription());
1454       return buf.toString();
1455    }
1456 
1457    protected String genInterpreterCodeletLinkPageHref(StubQueue stubq) {
1458       return genBaseHref() + "interp_codelets";
1459    }
1460 
1461    public String genInterpreterCodeletLinksPage() {
1462       Formatter buf = new Formatter(genHTML);
1463       buf.genHTMLPrologue("Interpreter Codelets");
1464       buf.beginTag("ul");
1465 
1466       Interpreter interp = VM.getVM().getInterpreter();
1467       StubQueue code = interp.getCode();
1468       InterpreterCodelet stub = (InterpreterCodelet) code.getFirst();
1469       while (stub != null) {
1470          buf.beginTag("li");
1471          sun.jvm.hotspot.debugger.Address addr = stub.codeBegin();
1472          buf.link(genPCHref(addressToLong(addr)), stub.getDescription() + " @" + addr);
1473          buf.endTag("li");
1474          stub = (InterpreterCodelet) code.getNext(stub);
1475       }
1476 
1477       buf.endTag("ul");
1478       buf.genHTMLEpilogue();
1479       return buf.toString();
1480    }
1481 
1482    public String genHTML(InterpreterCodelet codelet) {
1483       Formatter buf = new Formatter(genHTML);
1484       buf.genHTMLPrologue(genInterpreterCodeletTitle(codelet));
1485       Interpreter interp = VM.getVM().getInterpreter();
1486       StubQueue stubq = interp.getCode();
1487 
1488       if (genHTML) {
1489          buf.beginTag("h3");
1490          buf.link(genInterpreterCodeletLinkPageHref(stubq), "View links for all codelets");
1491          buf.endTag("h3");
1492          buf.br();
1493       }
1494 
1495       Stub prev = stubq.getPrev(codelet);
1496       if (prev != null) {
1497          if (genHTML) {
1498             buf.beginTag("h3");
1499             buf.link(genPCHref(addressToLong(prev.codeBegin())), "View Previous Codelet");
1500             buf.endTag("h3");
1501             buf.br();
1502          } else {
1503             buf.h3("Previous Codelet = 0x" + Long.toHexString(addressToLong(prev.codeBegin())));
1504          }
1505       }
1506 
1507       buf.h3("Code");
1508       Disassembler.decode(new HTMLDisassembler(buf, null), null,
1509                           codelet.codeBegin(), codelet.codeEnd());
1510 
1511       Stub next = stubq.getNext(codelet);
1512       if (next != null) {
1513          if (genHTML) {
1514             buf.beginTag("h3");
1515             buf.link(genPCHref(addressToLong(next.codeBegin())), "View Next Codelet");
1516             buf.endTag("h3");
1517          } else {
1518             buf.h3("Next Codelet = 0x" + Long.toHexString(addressToLong(next.codeBegin())));
1519          }
1520       }
1521 
1522       buf.genHTMLEpilogue();
1523       return buf.toString();
1524    }
1525 
1526    protected String genDumpKlassesTitle(InstanceKlass[] klasses) {
1527       return (klasses.length == 1) ? "Create .class for this class"
1528                                    : "Create .class for all classes";
1529    }
1530 
1531    protected String genDumpKlassesHref(InstanceKlass[] klasses) {
1532       StringBuffer buf = new StringBuffer(genBaseHref());
1533       buf.append("jcore_multiple=");
1534       for (int k = 0; k < klasses.length; k++) {
1535          buf.append(klasses[k].getAddress().toString());
1536          buf.append(',');
1537       }
1538       return buf.toString();
1539    }
1540 
1541    protected String genDumpKlassesLink(InstanceKlass[] klasses) {
1542       if (!genHTML) return "";
1543 
1544       Formatter buf = new Formatter(genHTML);
1545       buf.link(genDumpKlassesHref(klasses), genDumpKlassesTitle(klasses));
1546       return buf.toString();
1547    }
1548 
1549    public String genHTMLForKlassNames(InstanceKlass[] klasses) {
1550       try {
1551          Formatter buf = new Formatter(genHTML);
1552          buf.genHTMLPrologue();
1553          buf.h3(genDumpKlassesLink(klasses));
1554 
1555          buf.append(genHTMLListForKlassNames(klasses));
1556          buf.genHTMLEpilogue();
1557          return buf.toString();
1558       } catch (Exception exp) {
1559          return genHTMLErrorMessage(exp);
1560       }
1561    }
1562 
1563    protected String genHTMLListForKlassNames(InstanceKlass[] klasses) {
1564       final Formatter buf = new Formatter(genHTML);
1565       buf.beginTable(0);
1566       for (int i = 0; i < klasses.length; i++) {
1567          InstanceKlass ik = klasses[i];
1568          buf.beginTag("tr");
1569          buf.cell(genKlassLink(ik));
1570          buf.endTag("tr");
1571       }
1572 
1573       buf.endTable();
1574       return buf.toString();
1575    }
1576 
1577    public String genHTMLForMethodNames(InstanceKlass klass) {
1578       try {
1579          Formatter buf = new Formatter(genHTML);
1580          buf.genHTMLPrologue();
1581          buf.append(genHTMLListForMethods(klass));
1582          buf.genHTMLEpilogue();
1583          return buf.toString();
1584       } catch (Exception exp) {
1585          return genHTMLErrorMessage(exp);
1586       }
1587    }
1588 
1589    protected String genHTMLListForMethods(InstanceKlass klass) {
1590       Formatter buf = new Formatter(genHTML);
1591       MethodArray methods = klass.getMethods();
1592       int numMethods = methods.length();
1593       if (numMethods != 0) {
1594          buf.h3("Methods");
1595          buf.beginTag("ul");
1596          for (int m = 0; m < numMethods; m++) {
1597             Method mtd = methods.at(m);
1598             buf.li(genMethodLink(mtd) + ";");
1599          }
1600          buf.endTag("ul");
1601       }
1602       return buf.toString();
1603    }
1604 
1605    protected String genHTMLListForInterfaces(InstanceKlass klass) {
1606       try {
1607          Formatter buf = new Formatter(genHTML);
1608          KlassArray interfaces = klass.getLocalInterfaces();
1609          int numInterfaces = interfaces.length();
1610          if (numInterfaces != 0) {
1611             buf.h3("Interfaces");
1612             buf.beginTag("ul");
1613             for (int i = 0; i < numInterfaces; i++) {
1614                InstanceKlass inf = (InstanceKlass) interfaces.getAt(i);
1615                buf.li(genKlassLink(inf));
1616             }
1617             buf.endTag("ul");
1618          }
1619          return buf.toString();
1620       } catch (Exception exp) {
1621          return genHTMLErrorMessage(exp);
1622       }
1623    }
1624 
1625    protected String genFieldModifierString(AccessFlags acc) {
1626       Formatter buf = new Formatter(genHTML);
1627       if (acc.isPrivate()) {
1628          buf.append("private ");
1629       } else if (acc.isProtected()) {
1630          buf.append("protected ");
1631       } else if (acc.isPublic()) {
1632          buf.append("public ");
1633       }
1634 
1635       if (acc.isStatic()) {
1636          buf.append("static ");
1637       }
1638 
1639       if (acc.isFinal()) {
1640          buf.append("final ");
1641       }
1642       if (acc.isVolatile()) {
1643          buf.append("volatile ");
1644       }
1645       if (acc.isTransient()) {
1646          buf.append("transient ");
1647       }
1648 
1649       // javac generated flags
1650       if (acc.isSynthetic()) {
1651          buf.append("[synthetic] ");
1652       }
1653       return buf.toString();
1654    }
1655 
1656    public String genHTMLForFieldNames(InstanceKlass klass) {
1657       try {
1658          Formatter buf = new Formatter(genHTML);
1659          buf.genHTMLPrologue();
1660          buf.append(genHTMLListForFields(klass));
1661          buf.genHTMLEpilogue();
1662          return buf.toString();
1663       } catch (Exception exp) {
1664          return genHTMLErrorMessage(exp);
1665       }
1666    }
1667 
1668    protected String genHTMLListForFields(InstanceKlass klass) {
1669       Formatter buf = new Formatter(genHTML);
1670       U2Array fields = klass.getFields();
1671       int numFields = klass.getAllFieldsCount();
1672       if (numFields != 0) {
1673          buf.h3("Fields");
1674          buf.beginList();
1675          for (int f = 0; f < numFields; f++) {
1676            sun.jvm.hotspot.oops.Field field = klass.getFieldByIndex(f);
1677            String f_name = ((NamedFieldIdentifier)field.getID()).getName();
1678            Symbol f_sig  = field.getSignature();
1679            Symbol f_genSig = field.getGenericSignature();
1680            AccessFlags acc = field.getAccessFlagsObj();
1681 
1682            buf.beginListItem();
1683            buf.append(genFieldModifierString(acc));
1684            buf.append(' ');
1685            Formatter sigBuf = new Formatter(genHTML);
1686            new SignatureConverter(f_sig, sigBuf.getBuffer()).dispatchField();
1687            buf.append(sigBuf.toString().replace('/', '.'));
1688            buf.append(' ');
1689            buf.append(f_name);
1690            buf.append(';');
1691            // is it generic?
1692            if (f_genSig != null) {
1693               buf.append(" [signature ");
1694               buf.append(escapeHTMLSpecialChars(f_genSig.asString()));
1695               buf.append("] ");
1696            }
1697            buf.append(" (offset = " + field.getOffset() + ")");
1698            buf.endListItem();
1699          }
1700          buf.endList();
1701       }
1702       return buf.toString();
1703    }
1704 
1705    protected String genKlassHierarchyHref(InstanceKlass klass) {
1706       return genBaseHref() + "hierarchy=" + klass.getAddress();
1707    }
1708 
1709    protected String genKlassHierarchyTitle(InstanceKlass klass) {
1710       Formatter buf = new Formatter(genHTML);
1711       buf.append("Class Hierarchy of ");
1712       buf.append(genKlassTitle(klass));
1713       return buf.toString();
1714    }
1715 
1716    protected String genKlassHierarchyLink(InstanceKlass klass) {
1717       Formatter buf = new Formatter(genHTML);
1718       buf.link(genKlassHierarchyHref(klass), genKlassHierarchyTitle(klass));
1719       return buf.toString();
1720    }
1721 
1722    protected String genHTMLListForSubKlasses(InstanceKlass klass) {
1723       Formatter buf = new Formatter(genHTML);
1724       Klass subklass = klass.getSubklassKlass();
1725       if (subklass != null) {
1726          buf.beginList();
1727          while (subklass != null) {
1728             if (subklass instanceof InstanceKlass) {
1729                buf.li(genKlassLink((InstanceKlass)subklass));
1730             }
1731             subklass = subklass.getNextSiblingKlass();
1732          }
1733          buf.endList();
1734       }
1735       return buf.toString();
1736    }
1737 
1738    public String genHTMLForKlassHierarchy(InstanceKlass klass) {
1739       Formatter buf = new Formatter(genHTML);
1740       buf.genHTMLPrologue(genKlassHierarchyTitle(klass));
1741 
1742 
1743       buf.beginTag("pre");
1744       buf.append(genKlassLink(klass));
1745       buf.br();
1746       StringBuffer tabs = new StringBuffer(tab);
1747       InstanceKlass superKlass = klass;
1748       while ( (superKlass = (InstanceKlass) superKlass.getSuper()) != null ) {
1749          buf.append(tabs);
1750          buf.append(genKlassLink(superKlass));
1751          tabs.append(tab);
1752          buf.br();
1753       }
1754       buf.endTag("pre");
1755 
1756       // generate subklass list
1757       Klass subklass = klass.getSubklassKlass();
1758       if (subklass != null) {
1759          buf.h3("Direct Subclasses");
1760          buf.append(genHTMLListForSubKlasses(klass));
1761       }
1762 
1763       buf.genHTMLEpilogue();
1764       return buf.toString();
1765    }
1766 
1767    protected String genDumpKlassHref(InstanceKlass klass) {
1768       return genBaseHref() + "jcore=" + klass.getAddress();
1769    }
1770 
1771    protected String genDumpKlassLink(InstanceKlass klass) {
1772       if (!genHTML) return "";
1773 
1774       Formatter buf = new Formatter(genHTML);
1775       buf.link(genDumpKlassHref(klass), "Create .class File");
1776       return buf.toString();
1777    }
1778 
1779    public String genHTML(InstanceKlass klass) {
1780       Formatter buf = new Formatter(genHTML);
1781       buf.genHTMLPrologue(genKlassTitle(klass));
1782       InstanceKlass superKlass = (InstanceKlass) klass.getSuper();
1783 
1784       if (genHTML) {
1785           // super class tree and subclass list
1786           buf.beginTag("h3");
1787           buf.link(genKlassHierarchyHref(klass), "View Class Hierarchy");
1788           buf.endTag("h3");
1789       }
1790 
1791       // jcore - create .class link
1792       buf.h3(genDumpKlassLink(klass));
1793 
1794       // super class
1795       if (superKlass != null) {
1796          buf.h3("Super Class");
1797          buf.append(genKlassLink(superKlass));
1798       }
1799 
1800       // interfaces
1801       buf.append(genHTMLListForInterfaces(klass));
1802 
1803       // fields
1804       buf.append(genHTMLListForFields(klass));
1805 
1806       // methods
1807       buf.append(genHTMLListForMethods(klass));
1808 
1809       // constant pool link
1810       buf.h3("Constant Pool");
1811       buf.append(genConstantPoolLink(klass.getConstants()));
1812 
1813       buf.genHTMLEpilogue();
1814       return buf.toString();
1815    }
1816 
1817    protected sun.jvm.hotspot.debugger.Address parseAddress(String address) {
1818       VM vm = VM.getVM();
1819       sun.jvm.hotspot.debugger.Address addr = vm.getDebugger().parseAddress(address);
1820       return addr;
1821    }
1822 
1823    protected long addressToLong(sun.jvm.hotspot.debugger.Address addr) {
1824       return VM.getVM().getDebugger().getAddressValue(addr);
1825    }
1826 
1827    protected sun.jvm.hotspot.debugger.Address longToAddress(long addr) {
1828       return parseAddress("0x" + Long.toHexString(addr));
1829    }
1830 
1831    protected Oop getOopAtAddress(sun.jvm.hotspot.debugger.Address addr) {
1832       OopHandle oopHandle = addr.addOffsetToAsOopHandle(0);
1833       return VM.getVM().getObjectHeap().newOop(oopHandle);
1834    }
1835 
1836    protected Oop getOopAtAddress(String address) {
1837       sun.jvm.hotspot.debugger.Address addr = parseAddress(address);
1838       return getOopAtAddress(addr);
1839    }
1840 
1841    protected Klass getKlassAtAddress(String address) {
1842       sun.jvm.hotspot.debugger.Address addr = parseAddress(address);
1843       return (Klass)Metadata.instantiateWrapperFor(addr);
1844    }
1845 
1846    protected Method getMethodAtAddress(String address) {
1847       sun.jvm.hotspot.debugger.Address addr = parseAddress(address);
1848       return (Method)Metadata.instantiateWrapperFor(addr);
1849    }
1850 
1851    protected ConstantPool getConstantPoolAtAddress(String address) {
1852       sun.jvm.hotspot.debugger.Address addr = parseAddress(address);
1853       return (ConstantPool) Metadata.instantiateWrapperFor(addr);
1854    }
1855 
1856    private void dumpKlass(InstanceKlass kls) throws IOException {
1857       String klassName = kls.getName().asString();
1858       klassName = klassName.replace('/', File.separatorChar);
1859       int index = klassName.lastIndexOf(File.separatorChar);
1860       File dir = null;
1861       if (index != -1) {
1862         String dirName = klassName.substring(0, index);
1863         dir =  new File(DUMP_KLASS_OUTPUT_DIR,  dirName);
1864       } else {
1865         dir = new File(DUMP_KLASS_OUTPUT_DIR);
1866       }
1867 
1868       dir.mkdirs();
1869       File f = new File(dir, klassName.substring(klassName.lastIndexOf(File.separatorChar) + 1)
1870                               + ".class");
1871       f.createNewFile();
1872       FileOutputStream fis = new FileOutputStream(f);
1873       ClassWriter cw = new ClassWriter(kls, fis);
1874       cw.write();
1875    }
1876 
1877    public String genDumpKlass(InstanceKlass kls) {
1878       try {
1879          dumpKlass(kls);
1880          Formatter buf = new Formatter(genHTML);
1881          buf.genHTMLPrologue(genKlassTitle(kls));
1882          buf.append(".class created for ");
1883          buf.append(genKlassLink(kls));
1884          buf.genHTMLEpilogue();
1885          return buf.toString();
1886       } catch(IOException exp) {
1887          return genHTMLErrorMessage(exp);
1888       }
1889    }
1890 
1891    protected String genJavaStackTraceTitle(JavaThread thread) {
1892       Formatter buf = new Formatter(genHTML);
1893       buf.append("Java Stack Trace for ");
1894       buf.append(thread.getThreadName());
1895       return buf.toString();
1896    }
1897 
1898    public String genHTMLForJavaStackTrace(JavaThread thread) {
1899       Formatter buf = new Formatter(genHTML);
1900       buf.genHTMLPrologue(genJavaStackTraceTitle(thread));
1901 
1902       buf.append("Thread state = ");
1903       buf.append(thread.getThreadState().toString());
1904       buf.br();
1905       buf.beginTag("pre");
1906       for (JavaVFrame vf = thread.getLastJavaVFrameDbg(); vf != null; vf = vf.javaSender()) {
1907          Method method = vf.getMethod();
1908          buf.append(" - ");
1909          buf.append(genMethodLink(method));
1910          buf.append(" @bci = " + vf.getBCI());
1911 
1912          int lineNumber = method.getLineNumberFromBCI(vf.getBCI());
1913          if (lineNumber != -1) {
1914             buf.append(", line = ");
1915             buf.append(lineNumber);
1916          }
1917 
1918          sun.jvm.hotspot.debugger.Address pc = vf.getFrame().getPC();
1919          if (pc != null) {
1920             buf.append(", pc = ");
1921             buf.link(genPCHref(addressToLong(pc)), pc.toString());
1922          }
1923 
1924          if (!method.isStatic() && !method.isNative()) {
1925             OopHandle oopHandle = vf.getLocals().oopHandleAt(0);
1926 
1927             if (oopHandle != null) {
1928                buf.append(", oop = ");
1929                buf.append(oopHandle.toString());
1930             }
1931          }
1932 
1933          if (vf.isCompiledFrame()) {
1934             buf.append(" (Compiled");
1935          }
1936          else if (vf.isInterpretedFrame()) {
1937             buf.append(" (Interpreted");
1938          }
1939 
1940          if (vf.mayBeImpreciseDbg()) {
1941             buf.append("; information may be imprecise");
1942          }
1943          buf.append(")");
1944          buf.br();
1945       }
1946 
1947       buf.endTag("pre");
1948       buf.genHTMLEpilogue();
1949       return buf.toString();
1950    }
1951 
1952    public String genHTMLForHyperlink(String href) {
1953       if (href.startsWith("klass=")) {
1954          href = href.substring(href.indexOf('=') + 1);
1955          Klass k = getKlassAtAddress(href);
1956          if (Assert.ASSERTS_ENABLED) {
1957             Assert.that(k instanceof InstanceKlass, "class= href with improper InstanceKlass!");
1958          }
1959          return genHTML((InstanceKlass) k);
1960       } else if (href.startsWith("method=")) {
1961          href = href.substring(href.indexOf('=') + 1);
1962          Method obj = getMethodAtAddress(href);
1963          if (Assert.ASSERTS_ENABLED) {
1964             Assert.that(obj instanceof Method, "method= href with improper Method!");
1965          }
1966          return genHTML(obj);
1967       } else if (href.startsWith("nmethod=")) {
1968          String addr = href.substring(href.indexOf('=') + 1);
1969          Object obj = VMObjectFactory.newObject(NMethod.class, parseAddress(addr));
1970          if (Assert.ASSERTS_ENABLED) {
1971             Assert.that(obj instanceof NMethod, "nmethod= href with improper NMethod!");
1972          }
1973          return genHTML((NMethod) obj);
1974       } else if (href.startsWith("pc=")) {
1975          String address = href.substring(href.indexOf('=') + 1);
1976          return genHTML(parseAddress(address));
1977       } else if (href.startsWith("pc_multiple=")) {
1978          int indexOfComma = href.indexOf(',');
1979          if (indexOfComma == -1) {
1980             String firstPC = href.substring(href.indexOf('=') + 1);
1981             return genHTMLForRawDisassembly(parseAddress(firstPC), null);
1982          } else {
1983             String firstPC = href.substring(href.indexOf('=') + 1, indexOfComma);
1984             return genHTMLForRawDisassembly(parseAddress(firstPC), href.substring(indexOfComma + 1));
1985          }
1986       } else if (href.startsWith("interp_codelets")) {
1987          return genInterpreterCodeletLinksPage();
1988       } else if (href.startsWith("hierarchy=")) {
1989          href = href.substring(href.indexOf('=') + 1);
1990          Klass obj = getKlassAtAddress(href);
1991          if (Assert.ASSERTS_ENABLED) {
1992             Assert.that(obj instanceof InstanceKlass, "class= href with improper InstanceKlass!");
1993          }
1994          return genHTMLForKlassHierarchy((InstanceKlass) obj);
1995       } else if (href.startsWith("cpool=")) {
1996          href = href.substring(href.indexOf('=') + 1);
1997          ConstantPool obj = getConstantPoolAtAddress(href);
1998          if (Assert.ASSERTS_ENABLED) {
1999             Assert.that(obj instanceof ConstantPool, "cpool= href with improper ConstantPool!");
2000          }
2001          return genHTML(obj);
2002       } else if (href.startsWith("jcore=")) {
2003          href = href.substring(href.indexOf('=') + 1);
2004          Klass obj = getKlassAtAddress(href);
2005          if (Assert.ASSERTS_ENABLED) {
2006             Assert.that(obj instanceof InstanceKlass, "jcore= href with improper InstanceKlass!");
2007          }
2008          return genDumpKlass((InstanceKlass) obj);
2009       } else if (href.startsWith("jcore_multiple=")) {
2010          href = href.substring(href.indexOf('=') + 1);
2011          Formatter buf = new Formatter(genHTML);
2012          buf.genHTMLPrologue();
2013          StringTokenizer st = new StringTokenizer(href, ",");
2014          while (st.hasMoreTokens()) {
2015             Klass obj = getKlassAtAddress(st.nextToken());
2016             if (Assert.ASSERTS_ENABLED) {
2017                Assert.that(obj instanceof InstanceKlass, "jcore_multiple= href with improper InstanceKlass!");
2018             }
2019 
2020             InstanceKlass kls = (InstanceKlass) obj;
2021             try {
2022                dumpKlass(kls);
2023                buf.append(".class created for ");
2024                buf.append(genKlassLink(kls));
2025             } catch(Exception exp) {
2026                buf.bold("can't .class for " +
2027                         genKlassTitle(kls) +
2028                         " : " +
2029                         exp.getMessage());
2030             }
2031             buf.br();
2032          }
2033 
2034          buf.genHTMLEpilogue();
2035          return buf.toString();
2036       } else {
2037          if (Assert.ASSERTS_ENABLED) {
2038             Assert.that(false, "unknown href link!");
2039          }
2040          return null;
2041       }
2042    }
2043 }