changes...extra accessible analysis

Fix bug for MGC garbage collection

changing to new traversers/examiners

more bug fixes

more changes...

changes

more changes

add rcr-pointer option

commit hacks to effect analysis...interfaces to allow disjoint/pointer analysis to be exchanged

Patch in effects analysis hooks....have to add new accessor methods...add interface for allocsite...

need to decouple effects from AllocSite

a new compiler flag, "-printlinenum", has been added to print out line numbers in the generated C codes

Remove compilation errors for MGC code with gc

my changes

changes: propagating line number references to flatnodes

more changes...

more changes...do node-based taints...taint edges...change taintset...

compiling again...

keep the current snapshot before making further changes.

Fix compilation problems for multicore code

changes towards taints

changes on the java grammar. the line number of a source code propagates to the ParserNode

Bug fix. Now the SPECjbb2005 can run with small workload that does not invoke gc

pushing changes

starting towards taints

bug fix...can now analyze specjbb...~44,000 lines of source code files in 42 seconds...

small hacks to speed up stuff...don't compute graphs for primitive field read/writes...just reuse other graphs that are the same

bug fixes for the day....lots of them

refactoring the lattice implementation / having a way to declare the variable with delta locations(declared by using single-value annotation) / working on comparison of single,composite, and delta locations.

Fix bug for synchronized blocks. Inside a synchronized block, there could have return statements. Need to make sure that the locks grabbed should have been released before these return statements execute

bug fix

lots of bugs

Fix bug in Class Library

bug fixes

put together parts of DFJ that assumed we did not know the interprocedural parent set of a given task

running on some benchmarks....

another benchmark working

a few more bugs fixed...lots of debug code

public interface for the later compiler phases

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.