[vmkit-commits] [vmkit] r71950 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.cpp JavaConstantPool.cpp Jnjvm.cpp Jnjvm.h

Nicolas Geoffray nicolas.geoffray at lip6.fr
Sat May 16 07:41:03 PDT 2009


Author: geoffray
Date: Sat May 16 09:41:02 2009
New Revision: 71950

URL: http://llvm.org/viewvc/llvm-project?rev=71950&view=rev
Log:
Malformed constant pools abort, we should have thrown an exception during
the (non-existent) verifier.


Modified:
    vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
    vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
    vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
    vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h

Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=71950&r1=71949&r2=71950&view=diff

==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Sat May 16 09:41:02 2009
@@ -871,9 +871,8 @@
 
   Reader reader(bytes);
   uint32 magic = reader.readU4();
-  if (magic != Jnjvm::Magic) {
-    JavaThread::get()->getJVM()->classFormatError("bad magic number %p", magic);
-  }
+  assert(magic == Jnjvm::Magic && "I've created a class but magic is no good!");
+
   /* uint16 minor = */ reader.readU2();
   /* uint16 major = */ reader.readU2();
   uint32 ctpSize = reader.readU2();
@@ -887,9 +886,7 @@
     ctpInfo->resolveClassName(reader.readU2());
   
   if (!(thisClassName->equals(name))) {
-    JavaThread::get()->getJVM()->classFormatError(
-        "try to load %s and found class named %s",
-        printString(), thisClassName->printString());
+    JavaThread::get()->getJVM()->classFormatError(this, thisClassName);
   }
 
   readParents(reader);

Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=71950&r1=71949&r2=71950&view=diff

==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Sat May 16 09:41:02 2009
@@ -43,9 +43,8 @@
 
 static uint32 unimplemented(JavaConstantPool* ctp, Reader& reader,
                             uint32 index) {
-  JavaThread::get()->getJVM()->classFormatError(
-                                    "unknown constant pool at index %d", 
-                                    index);
+  fprintf(stderr, "Unimplemented in constant pool: %d\n", index);
+  abort();
   return 1;
 }
 
@@ -181,10 +180,9 @@
 }
 
 const UTF8* JavaConstantPool::UTF8At(uint32 entry) {
-  if (! ((entry > 0) && (entry < ctpSize) && 
-        typeAt(entry) == ConstantUTF8)) {
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for utf8 at entry %d", entry);
+  if (!((entry > 0) && (entry < ctpSize) && typeAt(entry) == ConstantUTF8)) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
   }
   
   if (!ctpRes[entry]) {
@@ -228,46 +226,41 @@
 }
 
 float JavaConstantPool::FloatAt(uint32 entry) {
-  if (! ((entry > 0) && (entry < ctpSize) && 
-        typeAt(entry) == ConstantFloat)) {
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for float at entry %d", entry);
+  if (!((entry > 0) && (entry < ctpSize) && typeAt(entry) == ConstantFloat)) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
   }
   return ((float*)ctpDef)[entry];
 }
 
 sint32 JavaConstantPool::IntegerAt(uint32 entry) {
-  if (! ((entry > 0) && (entry < ctpSize) && 
-        typeAt(entry) == ConstantInteger)) {
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for integer at entry %d", entry);
+  if (!((entry > 0) && (entry < ctpSize) && typeAt(entry) == ConstantInteger)) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
   }
   return ((sint32*)ctpDef)[entry];
 }
 
 sint64 JavaConstantPool::LongAt(uint32 entry) {
-  if (! ((entry > 0) && (entry < ctpSize) && 
-        typeAt(entry) == ConstantLong)) {
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for long at entry %d", entry);
+  if (!((entry > 0) && (entry < ctpSize) && typeAt(entry) == ConstantLong)) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
   }
   return Reader::readLong(ctpDef[entry], ctpDef[entry + 1]);
 }
 
 double JavaConstantPool::DoubleAt(uint32 entry) {
-  if (! ((entry > 0) && (entry < ctpSize) && 
-        typeAt(entry) == ConstantDouble)) {
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for double at entry %d", entry);
+  if (!((entry > 0) && (entry < ctpSize) && typeAt(entry) == ConstantDouble)) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
   }
   return Reader::readDouble(ctpDef[entry], ctpDef[entry + 1]);
 }
 
 CommonClass* JavaConstantPool::isClassLoaded(uint32 entry) {
-  if (! ((entry > 0) && (entry < ctpSize) && 
-        typeAt(entry) == ConstantClass)) {
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for class at entry %d", entry);
+  if (!((entry > 0) && (entry < ctpSize) &&  typeAt(entry) == ConstantClass)) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
   }
   return (CommonClass*)ctpRes[entry];
 }
@@ -317,8 +310,8 @@
   void* res = ctpRes[index];
   if (!res) {
     if (typeAt(index) != ConstantNameAndType) {
-      JavaThread::get()->getJVM()->classFormatError(
-                "bad constant pool number for name/type at entry %d", index);
+      fprintf(stderr, "Malformed class %s\n", classDef->printString());
+      abort();
     }
     sint32 entry = ctpDef[index];
     const UTF8* type = UTF8At(entry & 0xFFFF);
@@ -333,8 +326,8 @@
   void* res = ctpRes[index];
   if (!res) {
     if (typeAt(index) != ConstantNameAndType) {
-      JavaThread::get()->getJVM()->classFormatError(
-                "bad constant pool number for name/type at entry %d", index);
+      fprintf(stderr, "Malformed class %s\n", classDef->printString());
+      abort();
     }
     sint32 entry = ctpDef[index];
     const UTF8* type = UTF8At(entry & 0xFFFF);
@@ -346,18 +339,21 @@
 }
 
 Typedef* JavaConstantPool::infoOfField(uint32 index) {
-  if (typeAt(index) != ConstantFieldref)
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for field at entry %d", index);
+  if (typeAt(index) != ConstantFieldref) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
+  }
+
   return resolveNameAndType(ctpDef[index] & 0xFFFF);
 }
 
 void JavaConstantPool::infoOfMethod(uint32 index, uint32 access, 
                                     CommonClass*& cl, JavaMethod*& meth) {
   uint8 id = typeAt(index);
-  if (id != ConstantMethodref && id != ConstantInterfaceMethodref)
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for method at entry %d", index);
+  if (id != ConstantMethodref && id != ConstantInterfaceMethodref) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
+  }
   
   Signdef* sign = resolveNameAndSign(ctpDef[index] & 0xFFFF);
   sint32 entry = ctpDef[index];
@@ -393,9 +389,10 @@
                                               const UTF8*& name,
                                               Signdef*& sign) {
   uint8 id = typeAt(index);
-  if (id != ConstantMethodref && id != ConstantInterfaceMethodref)
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for method at entry %d", index);
+  if (id != ConstantMethodref && id != ConstantInterfaceMethodref) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
+  }
   
   sign = resolveNameAndSign(ctpDef[index] & 0xFFFF);
   sint32 entry = ctpDef[index];
@@ -408,9 +405,10 @@
                                                           uint32 access,
                                                           Signdef* sign) {
   uint8 id = typeAt(index);
-  if (id != ConstantMethodref && id != ConstantInterfaceMethodref)
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for method at entry %d", index);
+  if (id != ConstantMethodref && id != ConstantInterfaceMethodref) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
+  }
   
   sint32 entry = ctpDef[index];
   sint32 ntIndex = entry & 0xFFFF;
@@ -434,9 +432,10 @@
                                                           const UTF8*& name) {
 
   uint8 id = typeAt(index);
-  if (id != ConstantMethodref && id != ConstantInterfaceMethodref)
-    JavaThread::get()->getJVM()->classFormatError(
-              "bad constant pool number for method at entry %d", index);
+  if (id != ConstantMethodref && id != ConstantInterfaceMethodref) {
+    fprintf(stderr, "Malformed class %s\n", classDef->printString());
+    abort();
+  }
   
   sint32 entry = ctpDef[index];
   sint32 ntIndex = entry & 0xFFFF;

Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=71950&r1=71949&r2=71950&view=diff

==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Sat May 16 09:41:02 2009
@@ -268,23 +268,6 @@
   return obj;
 }
 
-void Jnjvm::error(UserClass* cl, JavaMethod* init, const char* fmt, ...) {
-  char* tmp = (char*)alloca(4096);
-  if (fmt) {
-    va_list ap;
-    va_start(ap, fmt);
-    vsnprintf(tmp, 4096, fmt, ap);
-    va_end(ap);
-  }
-  
-  if (cl && !bootstrapLoader->getCompiler()->isStaticCompiling()) {
-    JavaObject* obj = CreateError(cl, init, fmt ? fmt : 0);
-    JavaThread::get()->throwException(obj);
-  } else {
-    throw std::string(tmp);
-  }
-}
-
 void Jnjvm::error(UserClass* cl, JavaMethod* init, JavaString* str) {
   JavaObject* obj = CreateError(cl, init, str);
   JavaThread::get()->throwException(obj);
@@ -573,11 +556,67 @@
         upcalls->InitClassNotFoundException, str);
 }
 
+void Jnjvm::classFormatError(UserClass* cl, const UTF8* name) {
+  uint32 size = 33 + name->size + cl->name->size;
+  ArrayUInt16* msg = (ArrayUInt16*)upcalls->ArrayOfChar->doNew(size, this);
+  uint32 i = 0;
+
+
+  msg->elements[i++] = 't';
+  msg->elements[i++] = 'r';
+  msg->elements[i++] = 'y';
+  msg->elements[i++] = ' ';
+  msg->elements[i++] = 't';
+  msg->elements[i++] = 'o';
+  msg->elements[i++] = ' ';
+  msg->elements[i++] = 'l';
+  msg->elements[i++] = 'o';
+  msg->elements[i++] = 'a';
+  msg->elements[i++] = 'd';
+  msg->elements[i++] = ' ';
+
+  for (sint32 j = 0; j < cl->name->size; ++j) {
+    if (cl->name->elements[j] == '/') msg->elements[i++] = '.';
+    else msg->elements[i++] = cl->name->elements[j];
+  }
+  
+  msg->elements[i++] = 'a';
+  msg->elements[i++] = 'n';
+  msg->elements[i++] = 'd';
+  msg->elements[i++] = ' ';
+  msg->elements[i++] = 'f';
+  msg->elements[i++] = 'o';
+  msg->elements[i++] = 'n';
+  msg->elements[i++] = 'd';
+  msg->elements[i++] = ' ';
+  msg->elements[i++] = 'c';
+  msg->elements[i++] = 'l';
+  msg->elements[i++] = 'a';
+  msg->elements[i++] = 's';
+  msg->elements[i++] = 's';
+  msg->elements[i++] = ' ';
+  msg->elements[i++] = 'n';
+  msg->elements[i++] = 'a';
+  msg->elements[i++] = 'm';
+  msg->elements[i++] = 'e';
+  msg->elements[i++] = 'd';
+  msg->elements[i++] = ' ';
+  
+  for (sint32 j = 0; j < name->size; ++j) {
+    if (name->elements[j] == '/') msg->elements[i++] = '.';
+    else msg->elements[i++] = name->elements[j];
+  }
+ 
+  assert(i == size + 1 && "Array overflow");
+
+  JavaString* str = constructString(msg);
+  error(upcalls->ClassFormatError, upcalls->InitClassFormatError, str);
+}
+
 
-void Jnjvm::classFormatError(const char* msg, ...) {
-  error(upcalls->ClassFormatError,
-        upcalls->InitClassFormatError,
-        msg);
+void Jnjvm::classFormatError(const char* msg) {
+  JavaString* str = asciizToStr(msg);
+  error(upcalls->ClassFormatError, upcalls->InitClassFormatError, str);
 }
 
 JavaString* Jnjvm::internalUTF8ToStr(const UTF8* utf8) {

Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=71950&r1=71949&r2=71950&view=diff

==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Sat May 16 09:41:02 2009
@@ -127,7 +127,6 @@
   /// that calls this functions. This is used internally by Jnjvm to control
   /// which pair class/method are used.
   ///
-  void error(UserClass* cl, JavaMethod* meth, const char* fmt, ...);
   void error(UserClass* cl, JavaMethod* meth, JavaString*);
   
   /// errorWithExcp - Throws an exception whose cause is the Java object excp.
@@ -275,7 +274,8 @@
   void noClassDefFoundError(const UTF8* name);
   void classNotFoundException(JavaString* str);
 
-  void classFormatError(const char* fmt, ...);
+  void classFormatError(UserClass* cl, const UTF8* name);
+  void classFormatError(const char* str);
   
   /// asciizToStr - Constructs a java/lang/String object from the given asciiz.
   ///





More information about the vmkit-commits mailing list