internal Method(ClassFile classFile, string[] utf8_cp, ClassFileParseOptions options, BigEndianBinaryReader br) : base(classFile, utf8_cp, br)
{
// vmspec 4.6 says that all flags, except ACC_STRICT are ignored on <clinit>
// however, since Java 7 it does need to be marked static
if(ReferenceEquals(Name, StringConstants.CLINIT) && ReferenceEquals(Signature, StringConstants.SIG_VOID) && (classFile.MajorVersion < 51 || IsStatic))
{
access_flags &= Modifiers.Strictfp;
access_flags |= (Modifiers.Static | Modifiers.Private);
}
else
{
// LAMESPEC: vmspec 4.6 says that abstract methods can not be strictfp (and this makes sense), but
// javac (pre 1.5) is broken and marks abstract methods as strictfp (if you put the strictfp on the class)
if((ReferenceEquals(Name, StringConstants.INIT) && (IsStatic || IsSynchronized || IsFinal || IsAbstract || IsNative))
|| (IsPrivate && IsPublic) || (IsPrivate && IsProtected) || (IsPublic && IsProtected)
|| (IsAbstract && (IsFinal || IsNative || IsPrivate || IsStatic || IsSynchronized))
|| (classFile.IsInterface && (!IsPublic || !IsAbstract)))
{
throw new ClassFormatError("{0} (Illegal method modifiers: 0x{1:X})", classFile.Name, access_flags);
}
}
int attributes_count = br.ReadUInt16();
for(int i = 0; i < attributes_count; i++)
{
switch(classFile.GetConstantPoolUtf8String(utf8_cp, br.ReadUInt16()))
{
case "Deprecated":
if(br.ReadUInt32() != 0)
{
throw new ClassFormatError("Invalid Deprecated attribute length");
}
flags |= FLAG_MASK_DEPRECATED;
break;
case "Code":
{
if(!code.IsEmpty)
{
throw new ClassFormatError("{0} (Duplicate Code attribute)", classFile.Name);
}
BigEndianBinaryReader rdr = br.Section(br.ReadUInt32());
code.Read(classFile, utf8_cp, this, rdr, options);
if(!rdr.IsAtEnd)
{
throw new ClassFormatError("{0} (Code attribute has wrong length)", classFile.Name);
}
break;
}
case "Exceptions":
{
if(exceptions != null)
{
throw new ClassFormatError("{0} (Duplicate Exceptions attribute)", classFile.Name);
}
BigEndianBinaryReader rdr = br.Section(br.ReadUInt32());
ushort count = rdr.ReadUInt16();
exceptions = new string[count];
for(int j = 0; j < count; j++)
{
exceptions[j] = classFile.GetConstantPoolClass(rdr.ReadUInt16());
}
if(!rdr.IsAtEnd)
{
throw new ClassFormatError("{0} (Exceptions attribute has wrong length)", classFile.Name);
}
break;
}
case "Signature":
if(classFile.MajorVersion < 49)
{
goto default;
}
if(br.ReadUInt32() != 2)
{
throw new ClassFormatError("Signature attribute has incorrect length");
}
signature = classFile.GetConstantPoolUtf8String(utf8_cp, br.ReadUInt16());
break;
case "RuntimeVisibleAnnotations":
if(classFile.MajorVersion < 49)
{
goto default;
}
annotations = ReadAnnotations(br, classFile, utf8_cp);
break;
case "RuntimeVisibleParameterAnnotations":
{
if(classFile.MajorVersion < 49)
{
goto default;
}
if(low == null)
{
low = new LowFreqData();
}
BigEndianBinaryReader rdr = br.Section(br.ReadUInt32());
byte num_parameters = rdr.ReadByte();
low.parameterAnnotations = new object[num_parameters][];
for(int j = 0; j < num_parameters; j++)
{
ushort num_annotations = rdr.ReadUInt16();
low.parameterAnnotations[j] = new object[num_annotations];
for(int k = 0; k < num_annotations; k++)
{
low.parameterAnnotations[j][k] = ReadAnnotation(rdr, classFile, utf8_cp);
}
}
if(!rdr.IsAtEnd)
{
throw new ClassFormatError("{0} (RuntimeVisibleParameterAnnotations attribute has wrong length)", classFile.Name);
}
break;
}
case "AnnotationDefault":
{
if(classFile.MajorVersion < 49)
{
goto default;
}
if(low == null)
{
low = new LowFreqData();
}
BigEndianBinaryReader rdr = br.Section(br.ReadUInt32());
low.annotationDefault = ReadAnnotationElementValue(rdr, classFile, utf8_cp);
if(!rdr.IsAtEnd)
{
throw new ClassFormatError("{0} (AnnotationDefault attribute has wrong length)", classFile.Name);
}
break;
}
#if STATIC_COMPILER
case "RuntimeInvisibleAnnotations":
if(classFile.MajorVersion < 49)
{
goto default;
}
foreach(object[] annot in ReadAnnotations(br, classFile, utf8_cp))
{
if(annot[1].Equals("Likvm/lang/Internal;"))
{
if (classFile.IsInterface)
{
StaticCompiler.IssueMessage(Message.InterfaceMethodCantBeInternal, classFile.Name, this.Name, this.Signature);
}
else
{
this.access_flags &= ~Modifiers.AccessMask;
flags |= FLAG_MASK_INTERNAL;
}
}
if(annot[1].Equals("Likvm/internal/HasCallerID;"))
{
flags |= FLAG_HAS_CALLERID;
}
if(annot[1].Equals("Likvm/lang/DllExport;"))
{
string name = null;
int? ordinal = null;
for (int j = 2; j < annot.Length; j += 2)
{
if (annot[j].Equals("name") && annot[j + 1] is string)
{
name = (string)annot[j + 1];
}
else if (annot[j].Equals("ordinal") && annot[j + 1] is int)
{
ordinal = (int)annot[j + 1];
}
}
if (name != null && ordinal != null)
{
if (!IsStatic)
{
StaticCompiler.IssueMessage(Message.DllExportMustBeStaticMethod, classFile.Name, this.Name, this.Signature);
}
else
{
if (low == null)
{
low = new LowFreqData();
}
low.DllExportName = name;
low.DllExportOrdinal = ordinal.Value;
}
}
}
}
break;
#endif
default:
br.Skip(br.ReadUInt32());
break;
}
}
if(IsAbstract || IsNative)
{
if(!code.IsEmpty)
{
throw new ClassFormatError("Abstract or native method cannot have a Code attribute");
}
}
else
{
if(code.IsEmpty)
{
if(ReferenceEquals(this.Name, StringConstants.CLINIT))
{
code.verifyError = string.Format("Class {0}, method {1} signature {2}: No Code attribute", classFile.Name, this.Name, this.Signature);
return;
}
throw new ClassFormatError("Method has no Code attribute");
}
}
}
internal void Read(ClassFile classFile, string[] utf8_cp, Method method, BigEndianBinaryReader br, ClassFileParseOptions options)
{
max_stack = br.ReadUInt16();
max_locals = br.ReadUInt16();
uint code_length = br.ReadUInt32();
if(code_length > 65535)
{
throw new ClassFormatError("{0} (Invalid Code length {1})", classFile.Name, code_length);
}
Instruction[] instructions = new Instruction[code_length + 1];
int basePosition = br.Position;
int instructionIndex = 0;
try
{
BigEndianBinaryReader rdr = br.Section(code_length);
while(!rdr.IsAtEnd)
{
instructions[instructionIndex].Read((ushort)(rdr.Position - basePosition), rdr, classFile);
hasJsr |= instructions[instructionIndex].NormalizedOpCode == NormalizedByteCode.__jsr;
instructionIndex++;
}
// we add an additional nop instruction to make it easier for consumers of the code array
instructions[instructionIndex++].SetTermNop((ushort)(rdr.Position - basePosition));
}
catch(ClassFormatError x)
{
// any class format errors in the code block are actually verify errors
verifyError = x.Message;
}
this.instructions = new Instruction[instructionIndex];
Array.Copy(instructions, 0, this.instructions, 0, instructionIndex);
// build the pcIndexMap
int[] pcIndexMap = new int[this.instructions[instructionIndex - 1].PC + 1];
for(int i = 0; i < pcIndexMap.Length; i++)
{
pcIndexMap[i] = -1;
}
for(int i = 0; i < instructionIndex - 1; i++)
{
pcIndexMap[this.instructions[i].PC] = i;
}
// convert branch offsets to indexes
for(int i = 0; i < instructionIndex - 1; i++)
{
switch(this.instructions[i].NormalizedOpCode)
{
case NormalizedByteCode.__ifeq:
case NormalizedByteCode.__ifne:
case NormalizedByteCode.__iflt:
case NormalizedByteCode.__ifge:
case NormalizedByteCode.__ifgt:
case NormalizedByteCode.__ifle:
case NormalizedByteCode.__if_icmpeq:
case NormalizedByteCode.__if_icmpne:
case NormalizedByteCode.__if_icmplt:
case NormalizedByteCode.__if_icmpge:
case NormalizedByteCode.__if_icmpgt:
case NormalizedByteCode.__if_icmple:
case NormalizedByteCode.__if_acmpeq:
case NormalizedByteCode.__if_acmpne:
case NormalizedByteCode.__ifnull:
case NormalizedByteCode.__ifnonnull:
case NormalizedByteCode.__goto:
case NormalizedByteCode.__jsr:
this.instructions[i].SetTargetIndex(pcIndexMap[this.instructions[i].Arg1 + this.instructions[i].PC]);
break;
case NormalizedByteCode.__tableswitch:
case NormalizedByteCode.__lookupswitch:
this.instructions[i].MapSwitchTargets(pcIndexMap);
break;
}
}
// read exception table
ushort exception_table_length = br.ReadUInt16();
exception_table = new ExceptionTableEntry[exception_table_length];
for(int i = 0; i < exception_table_length; i++)
{
ushort start_pc = br.ReadUInt16();
ushort end_pc = br.ReadUInt16();
ushort handler_pc = br.ReadUInt16();
ushort catch_type = br.ReadUInt16();
if(start_pc >= end_pc
|| end_pc > code_length
|| handler_pc >= code_length
|| (catch_type != 0 && !classFile.SafeIsConstantPoolClass(catch_type)))
{
throw new ClassFormatError("Illegal exception table: {0}.{1}{2}", classFile.Name, method.Name, method.Signature);
}
classFile.MarkLinkRequiredConstantPoolItem(catch_type);
// if start_pc, end_pc or handler_pc is invalid (i.e. doesn't point to the start of an instruction),
// the index will be -1 and this will be handled by the verifier
int startIndex = pcIndexMap[start_pc];
int endIndex;
if (end_pc == code_length)
{
// it is legal for end_pc to point to just after the last instruction,
// but since there isn't an entry in our pcIndexMap for that, we have
// a special case for this
endIndex = instructionIndex - 1;
}
else
{
endIndex = pcIndexMap[end_pc];
}
int handlerIndex = pcIndexMap[handler_pc];
exception_table[i] = new ExceptionTableEntry(startIndex, endIndex, handlerIndex, catch_type, i);
}
ushort attributes_count = br.ReadUInt16();
for(int i = 0; i < attributes_count; i++)
{
switch(classFile.GetConstantPoolUtf8String(utf8_cp, br.ReadUInt16()))
{
case "LineNumberTable":
if((options & ClassFileParseOptions.LineNumberTable) != 0)
{
BigEndianBinaryReader rdr = br.Section(br.ReadUInt32());
int count = rdr.ReadUInt16();
lineNumberTable = new LineNumberTableEntry[count];
for(int j = 0; j < count; j++)
{
lineNumberTable[j].start_pc = rdr.ReadUInt16();
lineNumberTable[j].line_number = rdr.ReadUInt16();
if(lineNumberTable[j].start_pc >= code_length)
{
throw new ClassFormatError("{0} (LineNumberTable has invalid pc)", classFile.Name);
}
}
if(!rdr.IsAtEnd)
{
throw new ClassFormatError("{0} (LineNumberTable attribute has wrong length)", classFile.Name);
}
}
else
{
br.Skip(br.ReadUInt32());
}
break;
case "LocalVariableTable":
if((options & ClassFileParseOptions.LocalVariableTable) != 0)
{
BigEndianBinaryReader rdr = br.Section(br.ReadUInt32());
int count = rdr.ReadUInt16();
localVariableTable = new LocalVariableTableEntry[count];
for(int j = 0; j < count; j++)
{
localVariableTable[j].start_pc = rdr.ReadUInt16();
localVariableTable[j].length = rdr.ReadUInt16();
localVariableTable[j].name = classFile.GetConstantPoolUtf8String(utf8_cp, rdr.ReadUInt16());
localVariableTable[j].descriptor = classFile.GetConstantPoolUtf8String(utf8_cp, rdr.ReadUInt16()).Replace('/', '.');
localVariableTable[j].index = rdr.ReadUInt16();
}
// NOTE we're intentionally not checking that we're at the end of the section
// (optional attributes shouldn't cause ClassFormatError)
}
else
{
br.Skip(br.ReadUInt32());
}
break;
default:
br.Skip(br.ReadUInt32());
break;
}
}
// build the argmap
string sig = method.Signature;
List<int> args = new List<int>();
int pos = 0;
if(!method.IsStatic)
{
args.Add(pos++);
}
for(int i = 1; sig[i] != ')'; i++)
{
args.Add(pos++);
switch(sig[i])
{
case 'L':
i = sig.IndexOf(';', i);
break;
case 'D':
case 'J':
args.Add(-1);
break;
case '[':
{
while(sig[i] == '[')
{
i++;
}
if(sig[i] == 'L')
{
i = sig.IndexOf(';', i);
}
break;
}
}
}
argmap = args.ToArray();
if(args.Count > max_locals)
{
throw new ClassFormatError("{0} (Arguments can't fit into locals)", classFile.Name);
}
}
internal FieldOrMethod(ClassFile classFile, string[] utf8_cp, BigEndianBinaryReader br)
{
access_flags = (Modifiers)br.ReadUInt16();
name = String.Intern(classFile.GetConstantPoolUtf8String(utf8_cp, br.ReadUInt16()));
descriptor = classFile.GetConstantPoolUtf8String(utf8_cp, br.ReadUInt16());
ValidateSig(classFile, descriptor);
descriptor = String.Intern(descriptor.Replace('/', '.'));
}
internal Field(ClassFile classFile, string[] utf8_cp, BigEndianBinaryReader br) : base(classFile, utf8_cp, br)
{
if((IsPrivate && IsPublic) || (IsPrivate && IsProtected) || (IsPublic && IsProtected)
|| (IsFinal && IsVolatile)
|| (classFile.IsInterface && (!IsPublic || !IsStatic || !IsFinal || IsTransient)))
{
throw new ClassFormatError("{0} (Illegal field modifiers: 0x{1:X})", classFile.Name, access_flags);
}
int attributes_count = br.ReadUInt16();
for(int i = 0; i < attributes_count; i++)
{
switch(classFile.GetConstantPoolUtf8String(utf8_cp, br.ReadUInt16()))
{
case "Deprecated":
if(br.ReadUInt32() != 0)
{
throw new ClassFormatError("Invalid Deprecated attribute length");
}
flags |= FLAG_MASK_DEPRECATED;
break;
case "ConstantValue":
{
if(br.ReadUInt32() != 2)
{
throw new ClassFormatError("Invalid ConstantValue attribute length");
}
ushort index = br.ReadUInt16();
try
{
switch(Signature)
{
case "I":
constantValue = classFile.GetConstantPoolConstantInteger(index);
break;
case "S":
constantValue = (short)classFile.GetConstantPoolConstantInteger(index);
break;
case "B":
constantValue = (byte)classFile.GetConstantPoolConstantInteger(index);
break;
case "C":
constantValue = (char)classFile.GetConstantPoolConstantInteger(index);
break;
case "Z":
constantValue = classFile.GetConstantPoolConstantInteger(index) != 0;
break;
case "J":
constantValue = classFile.GetConstantPoolConstantLong(index);
break;
case "F":
constantValue = classFile.GetConstantPoolConstantFloat(index);
break;
case "D":
constantValue = classFile.GetConstantPoolConstantDouble(index);
break;
case "Ljava.lang.String;":
constantValue = classFile.GetConstantPoolConstantString(index);
break;
default:
throw new ClassFormatError("{0} (Invalid signature for constant)", classFile.Name);
}
}
catch(InvalidCastException)
{
throw new ClassFormatError("{0} (Bad index into constant pool)", classFile.Name);
}
catch(IndexOutOfRangeException)
{
throw new ClassFormatError("{0} (Bad index into constant pool)", classFile.Name);
}
catch(InvalidOperationException)
{
throw new ClassFormatError("{0} (Bad index into constant pool)", classFile.Name);
}
catch(NullReferenceException)
{
throw new ClassFormatError("{0} (Bad index into constant pool)", classFile.Name);
}
break;
}
case "Signature":
if(classFile.MajorVersion < 49)
{
goto default;
}
if(br.ReadUInt32() != 2)
{
throw new ClassFormatError("Signature attribute has incorrect length");
}
signature = classFile.GetConstantPoolUtf8String(utf8_cp, br.ReadUInt16());
break;
case "RuntimeVisibleAnnotations":
if(classFile.MajorVersion < 49)
{
goto default;
}
annotations = ReadAnnotations(br, classFile, utf8_cp);
break;
case "RuntimeInvisibleAnnotations":
if(classFile.MajorVersion < 49)
{
goto default;
}
foreach(object[] annot in ReadAnnotations(br, classFile, utf8_cp))
{
if(annot[1].Equals("Likvm/lang/Property;"))
{
DecodePropertyAnnotation(classFile, annot);
}
#if STATIC_COMPILER
else if(annot[1].Equals("Likvm/lang/Internal;"))
{
this.access_flags &= ~Modifiers.AccessMask;
flags |= FLAG_MASK_INTERNAL;
}
#endif
}
break;
default:
br.Skip(br.ReadUInt32());
break;
}
}
}
internal override void Resolve(ClassFile classFile, string[] utf8_cp, ClassFileParseOptions options)
{
ConstantPoolItemNameAndType name_and_type = (ConstantPoolItemNameAndType)classFile.GetConstantPoolItem(name_and_type_index);
// if the constant pool items referred to were strings, GetConstantPoolItem returns null
if (name_and_type == null)
{
throw new ClassFormatError("Bad index in constant pool");
}
name = String.Intern(classFile.GetConstantPoolUtf8String(utf8_cp, name_and_type.name_index));
descriptor = String.Intern(classFile.GetConstantPoolUtf8String(utf8_cp, name_and_type.descriptor_index).Replace('/', '.'));
}
internal override void Resolve(ClassFile classFile, string[] utf8_cp, ClassFileParseOptions options)
{
s = classFile.GetConstantPoolUtf8String(utf8_cp, string_index);
}
internal override void Resolve(ClassFile classFile, string[] utf8_cp, ClassFileParseOptions options)
{
if(classFile.GetConstantPoolUtf8String(utf8_cp, name_index) == null
|| classFile.GetConstantPoolUtf8String(utf8_cp, descriptor_index) == null)
{
throw new ClassFormatError("Illegal constant pool index");
}
}
internal override void Resolve(ClassFile classFile, string[] utf8_cp, ClassFileParseOptions options)
{
string descriptor = classFile.GetConstantPoolUtf8String(utf8_cp, signature_index);
if (descriptor == null || !IsValidMethodSig(descriptor))
{
throw new ClassFormatError("Invalid MethodType signature");
}
this.descriptor = String.Intern(descriptor.Replace('/', '.'));
}
internal override void Resolve(ClassFile classFile)
{
s = classFile.GetConstantPoolUtf8String(string_index);
}
internal override void Resolve(ClassFile classFile, string[] utf8_cp, ClassFileParseOptions options)
{
name = classFile.GetConstantPoolUtf8String(utf8_cp, name_index);
if(name.Length > 0)
{
// We don't enforce the strict class name rules in the static compiler, since HotSpot doesn't enforce *any* rules on
// class names for the system (and boot) class loader. We still need to enforce the 1.5 restrictions, because we
// rely on those invariants.
#if !STATIC_COMPILER
if(classFile.MajorVersion < 49 && (options & ClassFileParseOptions.RelaxedClassNameValidation) == 0)
{
char prev = name[0];
if(Char.IsLetter(prev) || prev == '$' || prev == '_' || prev == '[' || prev == '/')
{
int skip = 1;
int end = name.Length;
if(prev == '[')
{
if(!IsValidFieldSig(name))
{
goto barf;
}
while(name[skip] == '[')
{
skip++;
}
if(name.EndsWith(";"))
{
end--;
}
}
for(int i = skip; i < end; i++)
{
char c = name[i];
if(!Char.IsLetterOrDigit(c) && c != '$' && c != '_' && (c != '/' || prev == '/'))
{
goto barf;
}
prev = c;
}
name = String.Intern(name.Replace('/', '.'));
return;
}
}
else
#endif
{
// since 1.5 the restrictions on class names have been greatly reduced
int end = name.Length;
if(name[0] == '[')
{
if(!IsValidFieldSig(name))
{
goto barf;
}
// the semicolon is only allowed at the end and IsValidFieldSig enforces this,
// but since invalidJava15Characters contains the semicolon, we decrement end
// to make the following check against invalidJava15Characters ignore the
// trailing semicolon.
if(name[end - 1] == ';')
{
end--;
}
}
if(name.IndexOfAny(invalidJava15Characters, 0, end) >= 0)
{
goto barf;
}
name = String.Intern(name.Replace('/', '.'));
return;
}
}
barf:
throw new ClassFormatError("Invalid class name \"{0}\"", name);
}
internal override void Resolve(ClassFile classFile)
{
ConstantPoolItemNameAndType name_and_type = (ConstantPoolItemNameAndType) classFile.GetConstantPoolItem(name_and_type_index);
clazz = (ConstantPoolItemClass) classFile.GetConstantPoolItem(class_index);
// if the constant pool items referred to were strings, GetConstantPoolItem returns null
if (name_and_type == null || clazz == null)
{
throw new ClassFormatError("Bad index in constant pool");
}
name = String.Intern(classFile.GetConstantPoolUtf8String(name_and_type.name_index));
descriptor = classFile.GetConstantPoolUtf8String(name_and_type.descriptor_index);
Validate(name, descriptor);
descriptor = String.Intern(descriptor.Replace('/', '.'));
}
internal override void Resolve(ClassFile classFile)
{
name = classFile.GetConstantPoolUtf8String(name_index);
if (name.Length > 0)
{
char prev = name[0];
if (Char.IsLetter(prev) || prev == '$' || prev == '_' || prev == '[')
{
int skip = 1;
int end = name.Length;
if (prev == '[')
{
// TODO optimize this
if (!IsValidFieldSig(name))
{
goto barf;
}
while (name[skip] == '[')
{
skip++;
}
if (name.EndsWith(";"))
{
end--;
}
}
for (int i = skip; i < end; i++)
{
char c = name[i];
if (!Char.IsLetterOrDigit(c) && c != '$' && c != '_' && (c != '/' || prev == '/'))
{
goto barf;
}
prev = c;
}
name = String.Intern(name.Replace('/', '.'));
return;
}
}
barf:
throw new ClassFormatError("Invalid class name \"{0}\"", name);
}
internal void Read(ClassFile classFile, Method method, BigEndianBinaryReader br)
{
max_stack = br.ReadUInt16();
max_locals = br.ReadUInt16();
uint code_length = br.ReadUInt32();
if (code_length > 65536)
{
throw new ClassFormatError("{0} (Invalid Code length {1})", classFile.Name, code_length);
}
Instruction[] instructions = new Instruction[code_length + 1];
int basePosition = br.Position;
int instructionIndex = 0;
try
{
BigEndianBinaryReader rdr = br.Section(code_length);
while (!rdr.IsAtEnd)
{
instructions[instructionIndex++].Read((ushort) (rdr.Position - basePosition), rdr);
}
// we add an additional nop instruction to make it easier for consumers of the code array
instructions[instructionIndex++].SetTermNop((ushort) (rdr.Position - basePosition));
}
catch (ClassFormatError x)
{
// any class format errors in the code block are actually verify errors
verifyError = x.Message;
}
this.instructions = new Instruction[instructionIndex];
Array.Copy(instructions, 0, this.instructions, 0, instructionIndex);
ushort exception_table_length = br.ReadUInt16();
exception_table = new ExceptionTableEntry[exception_table_length];
for (int i = 0; i < exception_table_length; i++)
{
exception_table[i] = new ExceptionTableEntry();
exception_table[i].start_pc = br.ReadUInt16();
exception_table[i].end_pc = br.ReadUInt16();
exception_table[i].handler_pc = br.ReadUInt16();
exception_table[i].catch_type = br.ReadUInt16();
exception_table[i].ordinal = i;
}
ushort attributes_count = br.ReadUInt16();
for (int i = 0; i < attributes_count; i++)
{
switch (classFile.GetConstantPoolUtf8String(br.ReadUInt16()))
{
case "LineNumberTable":
br.Skip(br.ReadUInt32());
break;
case "LocalVariableTable":
br.Skip(br.ReadUInt32());
break;
default:
br.Skip(br.ReadUInt32());
break;
}
}
// build the pcIndexMap
pcIndexMap = new int[this.instructions[instructionIndex - 1].PC + 1];
for (int i = 0; i < pcIndexMap.Length; i++)
{
pcIndexMap[i] = -1;
}
for (int i = 0; i < instructionIndex - 1; i++)
{
pcIndexMap[this.instructions[i].PC] = i;
}
// build the argmap
string sig = method.Signature;
ArrayList args = new ArrayList();
int pos = 0;
if (!method.IsStatic)
{
args.Add(pos++);
}
for (int i = 1; sig[i] != ')'; i++)
{
args.Add(pos++);
switch (sig[i])
{
case 'L':
i = sig.IndexOf(';', i);
break;
case 'D':
case 'J':
args.Add(-1);
break;
case '[':
{
while (sig[i] == '[')
{
i++;
}
if (sig[i] == 'L')
{
i = sig.IndexOf(';', i);
}
break;
}
}
}
argmap = new int[args.Count];
args.CopyTo(argmap);
if (args.Count > max_locals)
{
throw new ClassFormatError("{0} (Arguments can't fit into locals)", classFile.Name);
}
}
internal Method(ClassFile classFile, BigEndianBinaryReader br) : base(classFile, br)
{
// vmspec 4.6 says that all flags, except ACC_STRICT are ignored on <clinit>
if (Name == "<clinit>" && Signature == "()V")
{
access_flags &= __Modifiers.Strictfp;
access_flags |= (__Modifiers.Static | __Modifiers.Private);
}
else
{
// LAMESPEC: vmspec 4.6 says that abstract methods can not be strictfp (and this makes sense), but
// javac (pre 1.5) is broken and marks abstract methods as strictfp (if you put the strictfp on the class)
if ((Name == "<init>" && (IsStatic || IsSynchronized || IsFinal || IsAbstract || IsNative))
|| (IsPrivate && IsPublic) || (IsPrivate && IsProtected) || (IsPublic && IsProtected)
|| (IsAbstract && (IsFinal || IsNative || IsPrivate || IsStatic || IsSynchronized))
|| (classFile.IsInterface && (!IsPublic || !IsAbstract)))
{
throw new ClassFormatError("{0} (Illegal method modifiers: 0x{1:X})", classFile.Name, access_flags);
}
}
int attributes_count = br.ReadUInt16();
for (int i = 0; i < attributes_count; i++)
{
switch (classFile.GetConstantPoolUtf8String(br.ReadUInt16()))
{
case "Deprecated":
deprecated = true;
#if FUZZ_HACK
br.Skip(br.ReadUInt32());
#else
if(br.ReadUInt32() != 0)
{
throw new ClassFormatError("{0} (Deprecated attribute has non-zero length)", classFile.Name);
}
#endif
break;
case "Code":
{
if (!code.IsEmpty)
{
throw new ClassFormatError("{0} (Duplicate Code attribute)", classFile.Name);
}
BigEndianBinaryReader rdr = br.Section(br.ReadUInt32());
code.Read(classFile, this, rdr);
if (!rdr.IsAtEnd)
{
throw new ClassFormatError("{0} (Code attribute has wrong length)", classFile.Name);
}
break;
}
case "Exceptions":
{
if (exceptions != null)
{
throw new ClassFormatError("{0} (Duplicate Exceptions attribute)", classFile.Name);
}
BigEndianBinaryReader rdr = br.Section(br.ReadUInt32());
ushort count = rdr.ReadUInt16();
exceptions = new string[count];
for (int j = 0; j < count; j++)
{
exceptions[j] = classFile.GetConstantPoolClass(rdr.ReadUInt16());
}
if (!rdr.IsAtEnd)
{
throw new ClassFormatError("{0} (Exceptions attribute has wrong length)", classFile.Name);
}
break;
}
default:
br.Skip(br.ReadUInt32());
break;
}
}
if (IsAbstract || IsNative)
{
if (!code.IsEmpty)
{
throw new ClassFormatError("Abstract or native method cannot have a Code attribute");
}
}
else
{
if (code.IsEmpty)
{
#if FUZZ_HACK
if (this.Name == "<clinit>")
{
code.verifyError = string.Format("Class {0}, method {1} signature {2}: No Code attribute", classFile.Name, this.Name, this.Signature);
return;
}
#endif
throw new ClassFormatError("Method has no Code attribute");
}
}
}
internal Field(ClassFile classFile, BigEndianBinaryReader br) : base(classFile, br)
{
if ((IsPrivate && IsPublic) || (IsPrivate && IsProtected) || (IsPublic && IsProtected)
|| (IsFinal && IsVolatile)
|| (classFile.IsInterface && (!IsPublic || !IsStatic || !IsFinal || IsTransient)))
{
throw new ClassFormatError("{0} (Illegal field modifiers: 0x{1:X})", classFile.Name, access_flags);
}
int attributes_count = br.ReadUInt16();
for (int i = 0; i < attributes_count; i++)
{
switch (classFile.GetConstantPoolUtf8String(br.ReadUInt16()))
{
case "Deprecated":
deprecated = true;
#if FUZZ_HACK
br.Skip(br.ReadUInt32());
#else
if(br.ReadUInt32() != 0)
{
throw new ClassFormatError("Deprecated attribute has non-zero length");
}
#endif
break;
case "ConstantValue":
{
if (br.ReadUInt32() != 2)
{
throw new ClassFormatError("Invalid ConstantValue attribute length");
}
ushort index = br.ReadUInt16();
try
{
switch (Signature)
{
case "I":
constantValue = classFile.GetConstantPoolConstantInteger(index);
break;
case "S":
constantValue = (short) classFile.GetConstantPoolConstantInteger(index);
break;
case "B":
constantValue = (byte) classFile.GetConstantPoolConstantInteger(index);
break;
case "C":
constantValue = (char) classFile.GetConstantPoolConstantInteger(index);
break;
case "Z":
constantValue = classFile.GetConstantPoolConstantInteger(index) != 0;
break;
case "J":
constantValue = classFile.GetConstantPoolConstantLong(index);
break;
case "F":
constantValue = classFile.GetConstantPoolConstantFloat(index);
break;
case "D":
constantValue = classFile.GetConstantPoolConstantDouble(index);
break;
case "Ljava.lang.String;":
constantValue = classFile.GetConstantPoolConstantString(index);
break;
default:
throw new ClassFormatError("{0} (Invalid signature for constant)", classFile.Name);
}
}
catch (InvalidCastException)
{
throw new ClassFormatError("{0} (Bad index into constant pool)", classFile.Name);
}
catch (IndexOutOfRangeException)
{
throw new ClassFormatError("{0} (Bad index into constant pool)", classFile.Name);
}
catch (InvalidOperationException)
{
throw new ClassFormatError("{0} (Bad index into constant pool)", classFile.Name);
}
catch (NullReferenceException)
{
throw new ClassFormatError("{0} (Bad index into constant pool)", classFile.Name);
}
break;
}
default:
br.Skip(br.ReadUInt32());
break;
}
}
}