From: bdemsky <bdemsky>
Date: Fri, 13 Feb 2009 06:46:42 +0000 (+0000)
Subject: Instanceof checks for jim
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=3e583d5e21e5c5da729ca68324c2beb180a6f990;p=IRC.git
Instanceof checks for jim
---
diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 7fee5bab..5110b2be 100644
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -193,6 +193,7 @@ public class BuildCode {
outstructs.close();
}
+
/* This code just generates the main C method for java programs.
* The main C method packs up the arguments into a string array
* and passes it to the java main method. */
@@ -349,6 +350,7 @@ public class BuildCode {
//Store the sizes of classes & array elements
generateSizeArray(outmethod);
+
//Store table of supertypes
generateSuperTypeTable(outmethod);
@@ -735,7 +737,6 @@ public class BuildCode {
}
}
-
/** Generate array that contains the sizes of class objects. The
* object allocation functions in the runtime use this
* information. */
@@ -792,6 +793,85 @@ public class BuildCode {
}
outclassdefs.println("};");
+
+ ClassDescriptor objectclass=typeutil.getClass(TypeUtil.ObjectClass);
+ needcomma=false;
+ outclassdefs.print("int typearray[]={");
+ for(int i=0;i<state.numClasses();i++) {
+ ClassDescriptor cd=cdarray[i];
+ ClassDescriptor supercd=cd.getSuperDesc();
+ if (needcomma)
+ outclassdefs.print(", ");
+ if (supercd==null)
+ outclassdefs.print("-1");
+ else
+ outclassdefs.print(supercd.getId());
+ needcomma=true;
+ }
+
+ for(int i=0;i<state.numArrays();i++) {
+ TypeDescriptor arraytd=arraytable[i];
+ ClassDescriptor arraycd=arraytd.getClassDesc();
+ if (arraycd==null) {
+ if (needcomma)
+ outclassdefs.print(", ");
+ outclassdefs.print(objectclass.getId());
+ needcomma=true;
+ continue;
+ }
+ ClassDescriptor cd=arraycd.getSuperDesc();
+ int type=-1;
+ while(cd!=null) {
+ TypeDescriptor supertd=new TypeDescriptor(cd);
+ supertd.setArrayCount(arraytd.getArrayCount());
+ type=state.getArrayNumber(supertd);
+ if (type!=-1) {
+ type+=state.numClasses();
+ break;
+ }
+ cd=cd.getSuperDesc();
+ }
+ if (needcomma)
+ outclassdefs.print(", ");
+ outclassdefs.print(type);
+ needcomma=true;
+ }
+
+ outclassdefs.println("};");
+
+ needcomma=false;
+
+
+ outclassdefs.print("int typearray2[]={");
+ for(int i=0;i<state.numArrays();i++) {
+ TypeDescriptor arraytd=arraytable[i];
+ ClassDescriptor arraycd=arraytd.getClassDesc();
+ if (arraycd==null) {
+ if (needcomma)
+ outclassdefs.print(", ");
+ outclassdefs.print("-1");
+ needcomma=true;
+ continue;
+ }
+ ClassDescriptor cd=arraycd.getSuperDesc();
+ int level=arraytd.getArrayCount()-1;
+ int type=-1;
+ for(;level>0;level--) {
+ TypeDescriptor supertd=new TypeDescriptor(objectclass);
+ supertd.setArrayCount(level);
+ type=state.getArrayNumber(supertd);
+ if (type!=-1) {
+ type+=state.numClasses();
+ break;
+ }
+ }
+ if (needcomma)
+ outclassdefs.print(", ");
+ outclassdefs.print(type);
+ needcomma=true;
+ }
+
+ outclassdefs.println("};");
}
/** Constructs params and temp objects for each method or task.
@@ -1440,6 +1520,10 @@ public class BuildCode {
generateFlatAtomicExitNode(fm, lb, (FlatAtomicExitNode) fn, output);
return;
+ case FKind.FlatInstanceOfNode:
+ generateFlatInstanceOfNode(fm, lb, (FlatInstanceOfNode)fn, output);
+ return;
+
case FKind.FlatSESEEnterNode:
generateFlatSESEEnterNode(fm, lb, (FlatSESEEnterNode) fn, output);
return;
@@ -1721,6 +1805,20 @@ public class BuildCode {
}
}
+ public void generateFlatInstanceOfNode(FlatMethod fm, LocalityBinding lb, FlatInstanceOfNode fion, PrintWriter output) {
+ int type;
+ if (fion.getType().isArray()) {
+ type=state.getArrayNumber(fion.getType())+state.numClasses();
+ } else {
+ type=fion.getType().getClassDesc().getId();
+ }
+
+ if (fion.getType().getSymbol().equals(TypeUtil.ObjectClass))
+ output.println(generateTemp(fm, fion.getDst(), lb)+"=1;");
+ else
+ output.println(generateTemp(fm, fion.getDst(), lb)+"=instanceof("+generateTemp(fm,fion.getSrc(),lb)+","+type+");");
+ }
+
public void generateFlatAtomicEnterNode(FlatMethod fm, LocalityBinding lb, FlatAtomicEnterNode faen, PrintWriter output) {
/* Check to see if we need to generate code for this atomic */
if (locality.getAtomic(lb).get(faen.getPrev(0)).intValue()>0)
diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
index 0b0fb922..f964dd12 100644
--- a/Robust/src/IR/Flat/BuildFlat.java
+++ b/Robust/src/IR/Flat/BuildFlat.java
@@ -789,6 +789,9 @@ public class BuildFlat {
case Kind.TertiaryNode:
return flattenTertiaryNode((TertiaryNode)en,out_temp);
+
+ case Kind.InstanceOfNode:
+ return flattenInstanceOfNode((InstanceOfNode)en,out_temp);
}
throw new Error();
}
@@ -1079,6 +1082,14 @@ public class BuildFlat {
return new NodePair(fn,null);
}
+ private NodePair flattenInstanceOfNode(InstanceOfNode tn, TempDescriptor out_temp) {
+ TempDescriptor expr_temp=TempDescriptor.tempFactory("expr",tn.getExpr().getType());
+ NodePair cond=flattenExpressionNode(tn.getExpr(), expr_temp);
+ FlatInstanceOfNode fion=new FlatInstanceOfNode(tn.getExprType(), expr_temp, out_temp);
+ cond.getEnd().addNext(fion);
+ return new NodePair(cond.getBegin(),fion);
+ }
+
private NodePair flattenTertiaryNode(TertiaryNode tn, TempDescriptor out_temp) {
TempDescriptor cond_temp=TempDescriptor.tempFactory("tert_cond",new TypeDescriptor(TypeDescriptor.BOOLEAN));
TempDescriptor true_temp=TempDescriptor.tempFactory("tert_true",tn.getTrueExpr().getType());
diff --git a/Robust/src/IR/Flat/FKind.java b/Robust/src/IR/Flat/FKind.java
index 4108296a..467337a5 100644
--- a/Robust/src/IR/Flat/FKind.java
+++ b/Robust/src/IR/Flat/FKind.java
@@ -25,4 +25,5 @@ public class FKind {
public static final int FlatOffsetNode=22;
public static final int FlatSESEEnterNode=23;
public static final int FlatSESEExitNode=24;
+ public static final int FlatInstanceOfNode=25;
}
diff --git a/Robust/src/IR/State.java b/Robust/src/IR/State.java
index 36ed57ba..e02d09d9 100644
--- a/Robust/src/IR/State.java
+++ b/Robust/src/IR/State.java
@@ -121,7 +121,7 @@ public class State {
public int getArrayNumber(TypeDescriptor td) {
if (arraytonumber.containsKey(td))
return ((Integer)arraytonumber.get(td)).intValue();
- else throw new Error("Could not find array type:" + td.toPrettyString());
+ else return -1;
}
public int numArrays() {
diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index deb48958..12149c3e 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -484,6 +484,10 @@ public class BuildIR {
return new TertiaryNode(parseExpression(pn.getChild("cond").getFirstChild()),
parseExpression(pn.getChild("trueexpr").getFirstChild()),
parseExpression(pn.getChild("falseexpr").getFirstChild()) );
+ } else if (isNode(pn, "instanceof")) {
+ ExpressionNode exp=parseExpression(pn.getChild("exp").getFirstChild());
+ TypeDescriptor t=parseTypeDescriptor(pn);
+ return new InstanceOfNode(exp,t);
} else {
System.out.println("---------------------");
System.out.println(pn.PPrint(3,true));
diff --git a/Robust/src/IR/Tree/Kind.java b/Robust/src/IR/Tree/Kind.java
index 7f26f7ff..7b93997a 100644
--- a/Robust/src/IR/Tree/Kind.java
+++ b/Robust/src/IR/Tree/Kind.java
@@ -26,4 +26,5 @@ public class Kind {
public final static int SESENode=23;
public final static int ContinueBreakNode=24;
public final static int TertiaryNode=25;
+ public final static int InstanceOfNode=26;
}
diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index dac024e0..0acbbe66 100644
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -399,6 +399,10 @@ public class SemanticCheck {
case Kind.TertiaryNode:
checkTertiaryNode(md, nametable, (TertiaryNode)en, td);
return;
+
+ case Kind.InstanceOfNode:
+ checkInstanceOfNode(md, nametable, (InstanceOfNode) en, td);
+ return;
}
throw new Error();
}
@@ -557,6 +561,14 @@ public class SemanticCheck {
checkExpressionNode(md, nametable, tn.getFalseExpr(), td );
}
+ void checkInstanceOfNode(Descriptor md, SymbolTable nametable, InstanceOfNode tn, TypeDescriptor td) {
+ if (!td.isBoolean())
+ throw new Error("Expecting type "+td+"for instanceof expression");
+
+ checkTypeDescriptor(tn.getExprType());
+ checkExpressionNode(md, nametable, tn.getExpr(), null);
+ }
+
void checkAssignmentNode(Descriptor md, SymbolTable nametable, AssignmentNode an, TypeDescriptor td) {
boolean postinc=true;
diff --git a/Robust/src/IR/TypeDescriptor.java b/Robust/src/IR/TypeDescriptor.java
index ddef4849..014f584f 100644
--- a/Robust/src/IR/TypeDescriptor.java
+++ b/Robust/src/IR/TypeDescriptor.java
@@ -74,6 +74,13 @@ public class TypeDescriptor extends Descriptor {
return arraycount;
}
+ /* Only use this method if you really know what you are doing. It
+ * doesn't have the effect you might expect. */
+
+ public void setArrayCount(int a) {
+ arraycount=a;
+ }
+
public TypeDescriptor dereference() {
TypeDescriptor td=new TypeDescriptor(getSymbol());
if (arraycount==0)
diff --git a/Robust/src/Parse/java14.cup b/Robust/src/Parse/java14.cup
index a1d07a81..6f6c2f31 100644
--- a/Robust/src/Parse/java14.cup
+++ b/Robust/src/Parse/java14.cup
@@ -1781,7 +1781,12 @@ relational_expression ::=
pn.addChild(exp2);
RESULT=pn;
:}
-// | relational_expression INSTANCEOF reference_type
+ | relational_expression:exp INSTANCEOF reference_type:type {:
+ ParseNode pn=new ParseNode("instanceof");
+ pn.addChild("exp").addChild(exp);
+ pn.addChild(type);
+ RESULT=pn;
+ :}
;
equality_expression ::=