Changes between Version 63 and Version 64 of IR

Timestamp:

11/25/15 21:22:47 (10 years ago)

Author:

siegel

Comment:

--

IR

@@ -189 +189 @@
  * `\padd(e1, e2)`: pointer addition. `e1` has pointer type and `e2` has an integer type or range type.  If `e2` has integer type the result has pointer type.   Otherwise, the result has `Mem` type.
  * `\psub(e1,e2)`: pointer subtraction
- * `\region(ptr)`, where `ptr` is an expression with a pointer type.  This represents the set of all memory units reachable from `ptr`, including the memory unit pointed to by `ptr` itself.
- * `\munion(mem1, mem2)`, where `mem1` and `mem2` are expressions of type `Memory`.  This is the union of the two memory sets.
- * `\misect(mem1, mem1)` : set intersection
- * `\mcomp(mem1)` : set complement (everything not in `mem1`)
- * `\aslice(a, dom)`, where `a` is an expression of array type and `dom` is an expression of `Domain` type.   The dimension of the array must match the dimension of the domain.   This represents all memory units which are the cells in the array indexed by a tuple in `dom`.
+ * `\mem_reach(ptr)`, where `ptr` is an expression with a pointer type.  This represents the set of all memory units reachable from `ptr`, including the memory unit pointed to by `ptr` itself.
+ * `\mem_union(mem1, mem2)`, where `mem1` and `mem2` are expressions of type `Memory`.  This is the union of the two memory sets.
+ * `\mem_isect(mem1, mem1)` : set intersection
+ * `\mem_comp(mem1)` : set complement (everything not in `mem1`)
+ * `\mem_slice(a, dom)`, where `a` is an expression of array type and `dom` is an expression of `Domain` type.   The dimension of the array must match the dimension of the domain.   This represents all memory units which are the cells in the array indexed by a tuple in `dom`.
 * Scopes and Processes
  * `\root`, `\here` : values of type `Scope`
@@ -215 +215 @@
 == The Primitive Statements ==
 
-* Assign:  `assign e1,e2;`
-* Call: `call f, <e1,...,en>;` and `\call e, f, <e1,...,en>;`
+* `ASSERT e, "msg", ...;` : assertion with message
+* `ASSUME e;`
+* `ASSIGN e1,e2;`
+* `CALL f, <e1,...,en>;` and `CALL e, f, <e1,...,en>;`
  * call to a function which is not abstract and is not a pure system function
-* Spawn: `\spawn f, (e1,...,en);` and `\spawn e, f, (e1,...,en);`
-* Wait: `\wait e;`
-* Wailtall: `\waitall e, n` where `e` is a pointer to a process reference and `n` is the number of processes to be waited for 
-* Allocation
- * `\allocate e, h, t, e0;`, where 
-  * `e` has type `Pointer`
-  * `h` has type `Heap`
-  * `t` has type `Dytype`
-  * `e0` has integer type.
- * Allocates `e0` objects of type `t` on heap `h`
- * To translate the C `malloc` you first need to figure out the type of the elements being malloced.  If the argument to malloc is `n`, then you first need to insert an assertion `\eq(\mod(n, \sizeof_type(t)), 0)`, and then `\allocate e, h, t, \div(n, \sizeof_type(t))`.
-* Free: `\free p;`
-* Expression statement: `e;`, where `e` is side effect free except that it might contain error/exception (e.g., array index out of bound, division by zero);
-* Noop: `;`
+* `SPAWN f, <e1,...,en>;` and `SPAWN e, f, <e1,...,en>;`
+* `WAIT e;`
+* `WAITALL e, n;` where `e` is a pointer to a process reference and `n` is the number of processes to be waited for 
+* `ALLOCATE e, h, t, e0;`
+ * `e` has type `Pointer`
+ * `h` has type `Heap`
+ * `t` has type `Dytype`
+ * `e0` has integer type.
+ * Allocates `e0` objects of type `t` on heap `h`, returning pointer to first element in `e`
+ * To translate the C `malloc` you first need to figure out the type of the elements being malloced.  If the argument to malloc is `n`, then you first need to insert an assertion `\eq(\mod(n, \sizeof_type(t)), 0)`, and then `ALLOCATE e, h, t, \div(n, \sizeof_type(t))`.
+* `FREE p;`
+* `EVAL e;`, where `e` is an expression that might contain exceptions (e.g., array index out of bound, division by zero);
+* `NOOP;`
  * **Is there a need to add annotations for "true" or "false" branch, etc.?**  If so, we can just make these parameters to the Noop.
-* Return: `\return;` and `\return e;`
-* Atomic_enter: `\atomic_enter;`
-* Atomic_exit: `\atomic_exit;`
-* Parfor_spawn: `\parspawn p, d, f;` where `p` is pointer to process reference, `d` has `Domain` type and `f` has `Function` type.
-* Domain iterator: `\next dom, <i,j,…>` updates `i`, `j`, ... to be the value of the inter tuple in `dom` after `<i, j, ...>`
-* For_dom_enter (for domains): `\for_enter dom;`
+* `RETURN;` and `RETURN e;`
+* `ATOMIC_ENTER;`
+* `ATOMIC_EXIT;`
+* `PARSPAWN p, d, f;` where `p` is pointer to process reference, `d` has `Domain` type and `f` has `Function` type.
+* `NEXT dom, <i,j,…>;` : domain iterator: updates `i`, `j`, ... to be the value of the inter tuple in `dom` after `<i, j, ...>`
+* `FOR_ENTER dom;` **FIX ME**
 
 == Declarations and Function Definitions ==