1 /*
   2  * Copyright (c) 1994, 2019, 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.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.tools.java;
  27 
  28 import java.io.IOException;
  29 import java.io.DataInputStream;
  30 import java.io.OutputStream;
  31 import java.io.DataOutputStream;
  32 import java.io.ByteArrayInputStream;
  33 import java.util.Hashtable;
  34 import java.util.Vector;
  35 import java.util.Enumeration;
  36 
  37 /**
  38  * WARNING: The contents of this source file are not part of any
  39  * supported API.  Code that depends on them does so at its own risk:
  40  * they are subject to change or removal without notice.
  41  */
  42 @SuppressWarnings("deprecation")
  43 public final
  44 class BinaryClass extends ClassDefinition implements Constants {
  45     BinaryConstantPool cpool;
  46     BinaryAttribute atts;
  47     Vector<ClassDeclaration> dependencies;
  48     private boolean haveLoadedNested = false;
  49 
  50     /**
  51      * Constructor
  52      */
  53     public BinaryClass(Object source, ClassDeclaration declaration, int modifiers,
  54                            ClassDeclaration superClass, ClassDeclaration interfaces[],
  55                            Vector<ClassDeclaration> dependencies) {
  56         super(source, 0, declaration, modifiers, null, null);
  57         this.dependencies = dependencies;
  58         this.superClass = superClass;
  59         this.interfaces = interfaces;
  60     }
  61 
  62     /**
  63      * Flags used by basicCheck() to avoid duplicate calls.
  64      * (Part of fix for 4105911)
  65      */
  66     private boolean basicCheckDone = false;
  67     private boolean basicChecking = false;
  68 
  69     /**
  70      * Ready a BinaryClass for further checking.  Note that, until recently,
  71      * BinaryClass relied on the default basicCheck() provided by
  72      * ClassDefinition.  The definition here has been added to ensure that
  73      * the information generated by collectInheritedMethods is available
  74      * for BinaryClasses.
  75      */
  76     protected void basicCheck(Environment env) throws ClassNotFound {
  77         if (tracing) env.dtEnter("BinaryClass.basicCheck: " + getName());
  78 
  79         // We need to guard against duplicate calls to basicCheck().  They
  80         // can lead to calling collectInheritedMethods() for this class
  81         // from within a previous call to collectInheritedMethods() for
  82         // this class.  That is not allowed.
  83         // (Part of fix for 4105911)
  84         if (basicChecking || basicCheckDone) {
  85             if (tracing) env.dtExit("BinaryClass.basicCheck: OK " + getName());
  86             return;
  87         }
  88 
  89         if (tracing) env.dtEvent("BinaryClass.basicCheck: CHECKING " + getName());
  90         basicChecking = true;
  91 
  92         super.basicCheck(env);
  93 
  94         // Collect inheritance information.
  95         if (doInheritanceChecks) {
  96             collectInheritedMethods(env);
  97         }
  98 
  99         basicCheckDone = true;
 100         basicChecking = false;
 101         if (tracing) env.dtExit("BinaryClass.basicCheck: " + getName());
 102     }
 103 
 104     /**
 105      * Load a binary class
 106      */
 107     public static BinaryClass load(Environment env, DataInputStream in) throws IOException {
 108         return load(env, in, ~(ATT_CODE|ATT_ALLCLASSES));
 109     }
 110 
 111     public static BinaryClass load(Environment env,
 112                                    DataInputStream in, int mask) throws IOException {
 113         // Read the header
 114         int magic = in.readInt();                    // JVM 4.1 ClassFile.magic
 115         if (magic != JAVA_MAGIC) {
 116             throw new ClassFormatError("wrong magic: " + magic + ", expected " + JAVA_MAGIC);
 117         }
 118         int minor_version = in.readUnsignedShort();  // JVM 4.1 ClassFile.minor_version
 119         int version = in.readUnsignedShort();        // JVM 4.1 ClassFile.major_version
 120         if (version < JAVA_MIN_SUPPORTED_VERSION) {
 121             throw new ClassFormatError(
 122                            sun.tools.javac.Main.getText(
 123                                "javac.err.version.too.old",
 124                                String.valueOf(version)));
 125         } else if ((version >= JAVA_MIN_PREVIEW_MAJOR_VERSION)
 126                      && (minor_version == JAVA_PREVIEW_MINOR_VERSION)) {
 127             // reject all class files that have preview features enabled
 128             throw new ClassFormatError(
 129                            sun.tools.javac.Main.getText(
 130                                "javac.err.version.preview",
 131                                version+"."+minor_version));
 132         } else if ((version > JAVA_MAX_SUPPORTED_VERSION)
 133                      || (version == JAVA_MAX_SUPPORTED_VERSION
 134                   && minor_version > JAVA_MAX_SUPPORTED_MINOR_VERSION)) {
 135             throw new ClassFormatError(
 136                            sun.tools.javac.Main.getText(
 137                                "javac.err.version.too.recent",
 138                                version+"."+minor_version));
 139         }
 140 
 141         // Read the constant pool
 142         BinaryConstantPool cpool = new BinaryConstantPool(in);
 143 
 144         // The dependencies of this class
 145         Vector<ClassDeclaration> dependencies = cpool.getDependencies(env);
 146 
 147         // Read modifiers
 148         int classMod = in.readUnsignedShort() & ACCM_CLASS;  // JVM 4.1 ClassFile.access_flags
 149 
 150         // Read the class name - from JVM 4.1 ClassFile.this_class
 151         ClassDeclaration classDecl = cpool.getDeclaration(env, in.readUnsignedShort());
 152 
 153         // Read the super class name (may be null) - from JVM 4.1 ClassFile.super_class
 154         ClassDeclaration superClassDecl = cpool.getDeclaration(env, in.readUnsignedShort());
 155 
 156         // Read the interface names - from JVM 4.1 ClassFile.interfaces_count
 157         ClassDeclaration interfaces[] = new ClassDeclaration[in.readUnsignedShort()];
 158         for (int i = 0 ; i < interfaces.length ; i++) {
 159             // JVM 4.1 ClassFile.interfaces[]
 160             interfaces[i] = cpool.getDeclaration(env, in.readUnsignedShort());
 161         }
 162 
 163         // Allocate the class
 164         BinaryClass c = new BinaryClass(null, classDecl, classMod, superClassDecl,
 165                                         interfaces, dependencies);
 166         c.cpool = cpool;
 167 
 168         // Add any additional dependencies
 169         c.addDependency(superClassDecl);
 170 
 171         // Read the fields
 172         int nfields = in.readUnsignedShort();  // JVM 4.1 ClassFile.fields_count
 173         for (int i = 0 ; i < nfields ; i++) {
 174             // JVM 4.5 field_info.access_flags
 175             int fieldMod = in.readUnsignedShort() & ACCM_FIELD;
 176             // JVM 4.5 field_info.name_index
 177             Identifier fieldName = cpool.getIdentifier(in.readUnsignedShort());
 178             // JVM 4.5 field_info.descriptor_index
 179             Type fieldType = cpool.getType(in.readUnsignedShort());
 180             BinaryAttribute atts = BinaryAttribute.load(in, cpool, mask);
 181             c.addMember(new BinaryMember(c, fieldMod, fieldType, fieldName, atts));
 182         }
 183 
 184         // Read the methods
 185         int nmethods = in.readUnsignedShort();  // JVM 4.1 ClassFile.methods_count
 186         for (int i = 0 ; i < nmethods ; i++) {
 187             // JVM 4.6 method_info.access_flags
 188             int methMod = in.readUnsignedShort() & ACCM_METHOD;
 189             // JVM 4.6 method_info.name_index
 190             Identifier methName = cpool.getIdentifier(in.readUnsignedShort());
 191             // JVM 4.6 method_info.descriptor_index
 192             Type methType = cpool.getType(in.readUnsignedShort());
 193             BinaryAttribute atts = BinaryAttribute.load(in, cpool, mask);
 194             c.addMember(new BinaryMember(c, methMod, methType, methName, atts));
 195         }
 196 
 197         // Read the class attributes
 198         c.atts = BinaryAttribute.load(in, cpool, mask);
 199 
 200         // See if the SourceFile is known
 201         byte data[] = c.getAttribute(idSourceFile);
 202         if (data != null) {
 203             DataInputStream dataStream = new DataInputStream(new ByteArrayInputStream(data));
 204             // JVM 4.7.2 SourceFile_attribute.sourcefile_index
 205             c.source = cpool.getString(dataStream.readUnsignedShort());
 206         }
 207 
 208         // See if the Documentation is know
 209         data = c.getAttribute(idDocumentation);
 210         if (data != null) {
 211             c.documentation = new DataInputStream(new ByteArrayInputStream(data)).readUTF();
 212         }
 213 
 214         // Was it compiled as deprecated?
 215         if (c.getAttribute(idDeprecated) != null) {
 216             c.modifiers |= M_DEPRECATED;
 217         }
 218 
 219         // Was it synthesized by the compiler?
 220         if (c.getAttribute(idSynthetic) != null) {
 221             c.modifiers |= M_SYNTHETIC;
 222         }
 223 
 224         return c;
 225     }
 226 
 227     /**
 228      * Called when an environment ties a binary definition to a declaration.
 229      * At this point, auxiliary definitions may be loaded.
 230      */
 231 
 232     public void loadNested(Environment env) {
 233         loadNested(env, 0);
 234     }
 235 
 236     public void loadNested(Environment env, int flags) {
 237         // Sanity check.
 238         if (haveLoadedNested) {
 239             // Duplicate calls most likely should not occur, but they do
 240             // in javap.  Be tolerant of them for the time being.
 241             // throw new CompilerError("multiple loadNested");
 242             if (tracing) env.dtEvent("loadNested: DUPLICATE CALL SKIPPED");
 243             return;
 244         }
 245         haveLoadedNested = true;
 246         // Read class-nesting information.
 247         try {
 248             byte data[];
 249             data = getAttribute(idInnerClasses);
 250             if (data != null) {
 251                 initInnerClasses(env, data, flags);
 252             }
 253         } catch (IOException ee) {
 254             // The inner classes attribute is not well-formed.
 255             // It may, for example, contain no data.  Report this.
 256             // We used to throw a CompilerError here (bug 4095108).
 257             env.error(0, "malformed.attribute", getClassDeclaration(),
 258                       idInnerClasses);
 259             if (tracing)
 260                 env.dtEvent("loadNested: MALFORMED ATTRIBUTE (InnerClasses)");
 261         }
 262     }
 263 
 264     private void initInnerClasses(Environment env,
 265                                   byte data[],
 266                                   int flags) throws IOException {
 267         DataInputStream ds = new DataInputStream(new ByteArrayInputStream(data));
 268         int nrec = ds.readUnsignedShort();  // InnerClasses_attribute.number_of_classes
 269         for (int i = 0; i < nrec; i++) {
 270             // For each inner class name transformation, we have a record
 271             // with the following fields:
 272             //
 273             //    u2 inner_class_info_index;   // CONSTANT_Class_info index
 274             //    u2 outer_class_info_index;   // CONSTANT_Class_info index
 275             //    u2 inner_name_index;         // CONSTANT_Utf8_info index
 276             //    u2 inner_class_access_flags; // access_flags bitmask
 277             //
 278             // The spec states that outer_class_info_index is 0 iff
 279             // the inner class is not a member of its enclosing class (i.e.
 280             // it is a local or anonymous class).  The spec also states
 281             // that if a class is anonymous then inner_name_index should
 282             // be 0.
 283             //
 284             // Prior to jdk1.2, javac did not implement the spec.  Instead
 285             // it <em>always</em> set outer_class_info_index to the
 286             // enclosing outer class and if the class was anonymous,
 287             // it set inner_name_index to be the index of a CONSTANT_Utf8
 288             // entry containing the null string "" (idNull).  This code is
 289             // designed to handle either kind of class file.
 290             //
 291             // See also the compileClass() method in SourceClass.java.
 292 
 293             // Read in the inner_class_info
 294             // InnerClasses_attribute.classes.inner_class_info_index
 295             int inner_index = ds.readUnsignedShort();
 296             // could check for zero.
 297             ClassDeclaration inner = cpool.getDeclaration(env, inner_index);
 298 
 299             // Read in the outer_class_info.  Note that the index will be
 300             // zero if the class is "not a member".
 301             ClassDeclaration outer = null;
 302             // InnerClasses_attribute.classes.outer_class_info_index
 303             int outer_index = ds.readUnsignedShort();
 304             if (outer_index != 0) {
 305                 outer = cpool.getDeclaration(env, outer_index);
 306             }
 307 
 308             // Read in the inner_name_index.  This may be zero.  An anonymous
 309             // class will either have an inner_nm_index of zero (as the spec
 310             // dictates) or it will have an inner_nm of idNull (for classes
 311             // generated by pre-1.2 compilers).  Handle both.
 312             Identifier inner_nm = idNull;
 313             // InnerClasses_attribute.classes.inner_name_index
 314             int inner_nm_index = ds.readUnsignedShort();
 315             if (inner_nm_index != 0) {
 316                 inner_nm = Identifier.lookup(cpool.getString(inner_nm_index));
 317             }
 318 
 319             // Read in the modifiers for the inner class.
 320             // InnerClasses_attribute.classes.inner_name_index
 321             int mods = ds.readUnsignedShort();
 322 
 323             // Is the class accessible?
 324             // The old code checked for
 325             //
 326             //    (!inner_nm.equals(idNull) && (mods & M_PRIVATE) == 0)
 327             //
 328             // which we will preserve to keep it working for class files
 329             // generated by 1.1 compilers.  In addition we check for
 330             //
 331             //    (outer != null)
 332             //
 333             // as an additional check that only makes sense with 1.2
 334             // generated files.  Note that it is entirely possible that
 335             // the M_PRIVATE bit is always enough.  We are being
 336             // conservative here.
 337             //
 338             // The ATT_ALLCLASSES flag causes the M_PRIVATE modifier
 339             // to be ignored, and is used by tools such as 'javap' that
 340             // wish to examine all classes regardless of the normal access
 341             // controls that apply during compilation.  Note that anonymous
 342             // and local classes are still not considered accessible, though
 343             // named local classes in jdk1.1 may slip through.  Note that
 344             // this accessibility test is an optimization, and it is safe to
 345             // err on the side of greater accessibility.
 346             boolean accessible =
 347                 (outer != null) &&
 348                 (!inner_nm.equals(idNull)) &&
 349                 ((mods & M_PRIVATE) == 0 ||
 350                  (flags & ATT_ALLCLASSES) != 0);
 351 
 352             // The reader should note that there has been a significant change
 353             // in the way that the InnerClasses attribute is being handled.
 354             // In particular, previously the compiler called initInner() for
 355             // <em>every</em> inner class.  Now the compiler does not call
 356             // initInner() if the inner class is inaccessible.  This means
 357             // that inaccessible inner classes don't have any of the processing
 358             // from initInner() done for them: fixing the access flags,
 359             // setting outerClass, setting outerMember in their outerClass,
 360             // etc.  We believe this is fine: if the class is inaccessible
 361             // and binary, then everyone who needs to see its internals
 362             // has already been compiled.  Hopefully.
 363 
 364             if (accessible) {
 365                 Identifier nm =
 366                     Identifier.lookupInner(outer.getName(), inner_nm);
 367 
 368                 // Tell the type module about the nesting relation:
 369                 Type.tClass(nm);
 370 
 371                 if (inner.equals(getClassDeclaration())) {
 372                     // The inner class in the record is this class.
 373                     try {
 374                         ClassDefinition outerClass = outer.getClassDefinition(env);
 375                         initInner(outerClass, mods);
 376                     } catch (ClassNotFound e) {
 377                         // report the error elsewhere
 378                     }
 379                 } else if (outer.equals(getClassDeclaration())) {
 380                     // The outer class in the record is this class.
 381                     try {
 382                         ClassDefinition innerClass =
 383                             inner.getClassDefinition(env);
 384                         initOuter(innerClass, mods);
 385                     } catch (ClassNotFound e) {
 386                         // report the error elsewhere
 387                     }
 388                 }
 389             }
 390         }
 391     }
 392 
 393     private void initInner(ClassDefinition outerClass, int mods) {
 394         if (getOuterClass() != null)
 395             return;             // already done
 396         /******
 397         // Maybe set static, protected, or private.
 398         if ((modifiers & M_PUBLIC) != 0)
 399             mods &= M_STATIC;
 400         else
 401             mods &= M_PRIVATE | M_PROTECTED | M_STATIC;
 402         modifiers |= mods;
 403         ******/
 404         // For an inner class, the class access may have been weakened
 405         // from that originally declared the source.  We must take the
 406         // actual access permissions against which we check any source
 407         // we are currently compiling from the InnerClasses attribute.
 408         // We attempt to guard here against bogus combinations of modifiers.
 409         if ((mods & M_PRIVATE) != 0) {
 410             // Private cannot be combined with public or protected.
 411             mods &= ~(M_PUBLIC | M_PROTECTED);
 412         } else if ((mods & M_PROTECTED) != 0) {
 413             // Protected cannot be combined with public.
 414             mods &= ~M_PUBLIC;
 415         }
 416         if ((mods & M_INTERFACE) != 0) {
 417             // All interfaces are implicitly abstract.
 418             // All interfaces that are members of a type are implicitly static.
 419             mods |= (M_ABSTRACT | M_STATIC);
 420         }
 421         if (outerClass.isInterface()) {
 422             // All types that are members of interfaces are implicitly
 423             // public and static.
 424             mods |= (M_PUBLIC | M_STATIC);
 425             mods &= ~(M_PRIVATE | M_PROTECTED);
 426         }
 427         modifiers = mods;
 428 
 429         setOuterClass(outerClass);
 430 
 431         for (MemberDefinition field = getFirstMember();
 432              field != null;
 433              field = field.getNextMember()) {
 434             if (field.isUplevelValue()
 435                     && outerClass.getType().equals(field.getType())
 436                     && field.getName().toString().startsWith(prefixThis)) {
 437                 setOuterMember(field);
 438             }
 439         }
 440     }
 441 
 442     private void initOuter(ClassDefinition innerClass, int mods) {
 443         if (innerClass instanceof BinaryClass)
 444             ((BinaryClass)innerClass).initInner(this, mods);
 445         addMember(new BinaryMember(innerClass));
 446     }
 447 
 448     /**
 449      * Write the class out to a given stream.  This function mirrors the loader.
 450      */
 451     public void write(Environment env, OutputStream out) throws IOException {
 452         DataOutputStream data = new DataOutputStream(out);
 453 
 454         // write out the header
 455         data.writeInt(JAVA_MAGIC);
 456         data.writeShort(env.getMinorVersion());
 457         data.writeShort(env.getMajorVersion());
 458 
 459         // Write out the constant pool
 460         cpool.write(data, env);
 461 
 462         // Write class information
 463         data.writeShort(getModifiers() & ACCM_CLASS);
 464         data.writeShort(cpool.indexObject(getClassDeclaration(), env));
 465         data.writeShort((getSuperClass() != null)
 466                         ? cpool.indexObject(getSuperClass(), env) : 0);
 467         data.writeShort(interfaces.length);
 468         for (int i = 0 ; i < interfaces.length ; i++) {
 469             data.writeShort(cpool.indexObject(interfaces[i], env));
 470         }
 471 
 472         // count the fields and the methods
 473         int fieldCount = 0, methodCount = 0;
 474         for (MemberDefinition f = firstMember; f != null; f = f.getNextMember())
 475             if (f.isMethod()) methodCount++; else fieldCount++;
 476 
 477         // write out each the field count, and then each field
 478         data.writeShort(fieldCount);
 479         for (MemberDefinition f = firstMember; f != null; f = f.getNextMember()) {
 480             if (!f.isMethod()) {
 481                 data.writeShort(f.getModifiers() & ACCM_FIELD);
 482                 String name = f.getName().toString();
 483                 String signature = f.getType().getTypeSignature();
 484                 data.writeShort(cpool.indexString(name, env));
 485                 data.writeShort(cpool.indexString(signature, env));
 486                 BinaryAttribute.write(((BinaryMember)f).atts, data, cpool, env);
 487             }
 488         }
 489 
 490         // write out each method count, and then each method
 491         data.writeShort(methodCount);
 492         for (MemberDefinition f = firstMember; f != null; f = f.getNextMember()) {
 493             if (f.isMethod()) {
 494                 data.writeShort(f.getModifiers() & ACCM_METHOD);
 495                 String name = f.getName().toString();
 496                 String signature = f.getType().getTypeSignature();
 497                 data.writeShort(cpool.indexString(name, env));
 498                 data.writeShort(cpool.indexString(signature, env));
 499                 BinaryAttribute.write(((BinaryMember)f).atts, data, cpool, env);
 500             }
 501         }
 502 
 503         // write out the class attributes
 504         BinaryAttribute.write(atts, data, cpool, env);
 505         data.flush();
 506     }
 507 
 508     /**
 509      * Get the dependencies
 510      */
 511     public Enumeration<ClassDeclaration> getDependencies() {
 512         return dependencies.elements();
 513     }
 514 
 515     /**
 516      * Add a dependency
 517      */
 518     public void addDependency(ClassDeclaration c) {
 519         if ((c != null) && !dependencies.contains(c)) {
 520             dependencies.addElement(c);
 521         }
 522     }
 523 
 524     /**
 525      * Get the constant pool
 526      */
 527     public BinaryConstantPool getConstants() {
 528         return cpool;
 529     }
 530 
 531     /**
 532      * Get a class attribute
 533      */
 534     public byte getAttribute(Identifier name)[] {
 535         for (BinaryAttribute att = atts ; att != null ; att = att.next) {
 536             if (att.name.equals(name)) {
 537                 return att.data;
 538             }
 539         }
 540         return null;
 541     }
 542 }