state machines for traverers seem to be working for small examples

more bug fixes...

even more bug fixes...3 test cases work

more bug fixes...two examples working

bug fixes...

Fix a bug of field initialization. Previously the field initializations are done in a reverse definition order. This could cause problem when a field's initialization depends on another fields initialization. As in the Java language specification, it is only specified that a instance field's initialization should be before its first usage in the field initializations, we simply change to do the field initializations in the same order as they are defined

bug fixes

changes

changes

Fix bugs in Class Library

Shrink the size of the final binary.  If it is too large it will have problem executing on Tilera.  We compress the virtual dispatch table: we use one row to represent the methods defined in interfaces that have the same prototype; and we do not generate colums for interfaces as there can not be instances of interfaces.  Moreover, we do not generate methods that are never invoked.

introduce new flag -ssjava for enabling SSJava feature and start working on the implementation of flow-down rule checking plus minor updates.

more code for state machines in dfj traversers

extend taints for a new mode in DFJ that helps build the state machine traversers

a tiny example to show if the state machines are working

add a second task to generate conflicts

changes

Fix bugs for interfaces. \n\nFor methods declared in interfaces, there always need virtual dispatch.\n\n The other bug is that previously the method numbering strategy always start from 0 when numbering a class'es method.  When there are no interfaces, all classes form a tree with Object as the root and the numbering works fine.  But with interfaces, the inherit hierachy would no longer be a tree and there will have serious problems.  #0 would be always assigned to some method of Object and every interfaces.  If a Class implements any interfaces, it would have at least two methods with #0 and it would only be able to access one of it and lose the others.  Also we need to make sure that each method of a interface should have a distinguished number so that when a class implements multiple interfaces, it would not lose access of any of the methods defined in the interfaces.  So when numbering the methods in Virtual, we first numbering all the methods in the interfaces and give them a distinguished number. Then we numbering the classes and start from the following number.  As interfaces could have methods with the same name, a method in a class could match multiple entries in its super interfaces/classes.  We record all these entries in order to fill in the virtual table correctly

add grammar for the definition of location hierarchy. location hierarchy is stored in the lattice data structure. class descriptor has a lattice object since each class maintains its own location hierarchy,

a functioning test program for stephen that produces a bad traverser for current dfj system

a test case showing a bug in disjoint analysis basic points-to stuff

more code changes

Add unit tests for Abstract class support, Enum type support, Field Initializer support, Interface support, Static inner class support, static field/block support, switch-case statement support, and try-catch support

Remove commented out code

changes

Fix bugs for interfaces and a bug in the Class library

more changes

more code cleanup

code cleanup

changes towards making this work

A small bug for Enum

Fix the field name for object.c and thread.c, there are no Class name prefix anymore

Fix bugs for static fields/blocks and instanceof operation.  To effectively support static fields/blocks, we need to generate a special version for methods that could be invoked in static blocks or when initializing static fields.  In the special version, if there are classes with static fields/blocks are involved, we'll check if the static fields have been initialized and if the static blocks have been executed.  Previously we misused C micros to implement this(MGC_STATIC_INIT_CHECK).  Now we remove this wrong macro and generate the required special version.  For instanceof operation, we fix two bugs.  One is that previously we did not take interfaces into consider and the other is that in the instanceof(struct Object *, int) function we did not check if the Object is NULL or not.  If the Object is NULL, we shall always return false.

add annotation descriptor. type descriptor is responsible for keeping corresponding annotations.

changes...

add java 1.5 annotation grammar for all types of annotation(marker, single value, and value pairs) but the current implementation only supports marker annotations which have no variables, just the annotation name.

missing include

changes

changes

add garbage collector support...

setup globals as a garbagelist...split primitives into separate file

work towards turning MGC enhancements on all the time

Remove the extra copy of static field in the object structures and change the classobj in global_defs_p as pointers. Also take interfaces into consider when do instanceof check in MGC runtime. There are still bugs to check instanceof for arrays

tabbing

big code reorg...get TM out of buildcode

My changes to add interface affect to FieldShadow

Make new field naming strategy work for MGC

make static fields work

commit bug fix

fix tabbing

throw away commented code

rename a few fields

make field shadowing work

changes

change

bug fix

rename field names

new approach to field shadowing

changes

Fix a bug of default constructor: the default constructor should construct the super class if there is any and also initialize the fields with initializers.

Fix a shadow field related bug in the compiler. Defined in Java language specification, if the class declares a field with a certain name, then the declaration of that field is said to hide any and all accessible declarations of fields with the same name in superclasses, and superinterfaces of the class. However, the hidden fields in superclasses or superinterfaces can still be accessed by using a qualified name (if it is static) or by using a field access expression that contains the keyword super or a cast to a superclass type. Previously, our compiler simply discarded all the hidden fields so that the hidden fields can never be accessed. Now we maitain all the fields including the hidden ones. We prefix the name of the class that defines the field to the field's name to differentiate the shadow field and the hidden fields. Some of the hard coded fields dereference in the Runtime C code are fixed accordingly. Now the unit tests, multicore benchmarks and oooJava related benchmarks are checked to be OK. But (D)STM related Runtime code are NOT checked yet.

Add some runtime support for MGC

Bug fix in array initialization: handle the special case like {{null,null}}

Bug fixes for MGC

Updates of the class library for MGC

some bug fix

Make special MGC versions of some library class like HashMap and Vector etc. to avoid braking compilation of non-MGC build

*** empty log message ***

More class library support for SPECjbb

As static blocks is compiled as a method without returntype, previous isConstructor check should be updated

Class library for SPECjbb

take pointer analysis out of the build for now

improve code gen to omit empty switch cases for stall sites

Roll back to use the simple Class constructor to support class lock.  Fix a bug for static field initialization: the initialization of a static field was invoked each time the field is used. The initialization of a static field should be invoked only once and be invoked before it is used. To simplify the implementation, we create a static block to contain the initializations of all the static fields of a class and invoke this static block at the beginning of the main method.

changes

fixing bugs from task code cleanup

This is a compile-stable update of OoOJava code, there are almost certainly bugs lurking...

bringing ooojava code gen around, some todos still to work out

BuildCode, with the monkey of OoOJava off its back

bringing analysis up to clean model, buildcode is left

starting to get into memory conflicts where cleaned up task model has more impact

honor the easy request of suppressing output for the disjoint reach pass that is the points-to only pass

pushing cleaned code further through analyses...

clean Pointer classes

cleaning up OoOJava and related systems, touching lots of files, these systems are PARTIALLY updated, the system is stable but won't compile user programs correctly until fully updated

more changes...

Fix the bug of assignment conversion: 'short s = 12' should be allowed. And for such case, in BuildFlat.java the right side of the assignment is replaced with the value.

Removed vestigial code left over from "waiting queues". Scratch previous comment about removing the need to coalesce weakly connected groups.

A missing file

The second to last check in for the refactoring process. This moved/renamed some things to make the code more obvious. The last checkin will eliminate the need to coalesce connected heap groups.

more changes

Enable array creation with initialization for MGC. Now array initialization is fully supported in MGC.

Enable field array initialization for MGC

more changes

Basic implementation of array initialization for mgc: local array declaration with array initialization is OK now. Need more work to enable array field declaration with initialization and array creation with initialization. Also fix a bug: previously do not support static fields that are object/array.

more work towards new points to analysis

changes

more changes

more changes

more changes