ruby: restrict Address to being a type and not a variable name

Change all occurrances of Address as a variable name to instead use Addr.
Address is an allowed name in slicc even when Address is also being used as a
type, leading to declarations of "Address Address". While this works, it
prevents adding another field of type Address because the compiler then thinks
Address is a variable name, not type.

Committed by: Nilay Vaish <nilay@cs.wisc.edu>

1 files changed, 106 insertions, 106 deletions

diff --git a/src/mem/protocol/MOESI_CMP_directory-L2cache.sm b/src/mem/protocol/MOESI_CMP_directory-L2cache.sm
index 475da1fbc..de776192d 100644
--- a/src/mem/protocol/MOESI_CMP_directory-L2cache.sm
+++ b/src/mem/protocol/MOESI_CMP_directory-L2cache.sm
@@ -187,7 +187,7 @@ machine(L2Cache, "Token protocol")
 
   // TBE fields
   structure(TBE, desc="...") {
-    Address address,                      desc="Physical address for this TBE";
+    Address Addr,                      desc="Physical address for this TBE";
     State TBEState,                       desc="Transient state";
     Address PC,                           desc="Program counter of request";
     DataBlock DataBlk,                    desc="Buffer for the data block";
@@ -540,8 +540,8 @@ machine(L2Cache, "Token protocol")
     if (triggerQueue_in.isReady()) {
       peek(triggerQueue_in, TriggerMsg) {
         if (in_msg.Type == TriggerType:ALL_ACKS) {
-          trigger(Event:All_Acks, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:All_Acks, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else {
           error("Unexpected message");
         }
@@ -556,27 +556,27 @@ machine(L2Cache, "Token protocol")
       peek(requestNetwork_in, RequestMsg) {
         if (in_msg.Type == CoherenceRequestType:GETX || in_msg.Type == CoherenceRequestType:DMA_WRITE) {
           if (in_msg.Requestor == machineID) {
-            trigger(Event:Own_GETX, in_msg.Address,
-                    getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+            trigger(Event:Own_GETX, in_msg.Addr,
+                    getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
           } else {
-            trigger(Event:Fwd_GETX, in_msg.Address,
-                    getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+            trigger(Event:Fwd_GETX, in_msg.Addr,
+                    getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
           }
         } else if (in_msg.Type == CoherenceRequestType:GETS) {
-          trigger(Event:Fwd_GETS, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:Fwd_GETS, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if(in_msg.Type == CoherenceRequestType:DMA_READ) {
-          trigger(Event:Fwd_DMA, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:Fwd_DMA, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceRequestType:INV) {
-          trigger(Event:Inv, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:Inv, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceRequestType:WB_ACK) {
-          trigger(Event:Writeback_Ack, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:Writeback_Ack, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceRequestType:WB_NACK) {
-          trigger(Event:Writeback_Nack, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:Writeback_Nack, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else {
           error("Unexpected message");
         }
@@ -589,26 +589,26 @@ machine(L2Cache, "Token protocol")
       peek(L1requestNetwork_in, RequestMsg) {
         assert(in_msg.Destination.isElement(machineID));
         if (in_msg.Type == CoherenceRequestType:GETX) {
-          trigger(Event:L1_GETX, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:L1_GETX, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceRequestType:GETS) {
-            trigger(Event:L1_GETS, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+            trigger(Event:L1_GETS, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceRequestType:PUTO) {
-          trigger(Event:L1_PUTO, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:L1_PUTO, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceRequestType:PUTX) {
-          trigger(Event:L1_PUTX, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:L1_PUTX, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceRequestType:PUTS) {
-          Entry cache_entry := getCacheEntry(in_msg.Address);
-          if (isOnlySharer(cache_entry, in_msg.Address, in_msg.Requestor)) {
-            trigger(Event:L1_PUTS_only, in_msg.Address,
-                    cache_entry, TBEs[in_msg.Address]);
+          Entry cache_entry := getCacheEntry(in_msg.Addr);
+          if (isOnlySharer(cache_entry, in_msg.Addr, in_msg.Requestor)) {
+            trigger(Event:L1_PUTS_only, in_msg.Addr,
+                    cache_entry, TBEs[in_msg.Addr]);
           }
           else {
-            trigger(Event:L1_PUTS, in_msg.Address,
-                    cache_entry, TBEs[in_msg.Address]);
+            trigger(Event:L1_PUTS, in_msg.Addr,
+                    cache_entry, TBEs[in_msg.Addr]);
           }
         } else {
           error("Unexpected message");
@@ -625,52 +625,52 @@ machine(L2Cache, "Token protocol")
         assert(in_msg.Destination.isElement(machineID));
         if (in_msg.Type == CoherenceResponseType:ACK) {
           if (in_msg.SenderMachine == MachineType:L2Cache) {
-            trigger(Event:ExtAck, in_msg.Address,
-                    getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+            trigger(Event:ExtAck, in_msg.Addr,
+                    getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
           }
           else {
-            trigger(Event:IntAck, in_msg.Address,
-                    getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+            trigger(Event:IntAck, in_msg.Addr,
+                    getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
           }
         } else if (in_msg.Type == CoherenceResponseType:DATA) {
-          trigger(Event:Data, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:Data, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceResponseType:DATA_EXCLUSIVE) {
-          trigger(Event:Data_Exclusive, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:Data_Exclusive, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceResponseType:UNBLOCK) {
-          trigger(Event:Unblock, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:Unblock, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceResponseType:UNBLOCK_EXCLUSIVE) {
-          trigger(Event:Exclusive_Unblock, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:Exclusive_Unblock, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else if (in_msg.Type == CoherenceResponseType:WRITEBACK_DIRTY_DATA) {
-          Entry cache_entry := getCacheEntry(in_msg.Address);
+          Entry cache_entry := getCacheEntry(in_msg.Addr);
           if (is_invalid(cache_entry) &&
-                   L2cache.cacheAvail(in_msg.Address) == false) {
-            trigger(Event:L2_Replacement, L2cache.cacheProbe(in_msg.Address),
-                    getCacheEntry(L2cache.cacheProbe(in_msg.Address)),
-                    TBEs[L2cache.cacheProbe(in_msg.Address)]);
+                   L2cache.cacheAvail(in_msg.Addr) == false) {
+            trigger(Event:L2_Replacement, L2cache.cacheProbe(in_msg.Addr),
+                    getCacheEntry(L2cache.cacheProbe(in_msg.Addr)),
+                    TBEs[L2cache.cacheProbe(in_msg.Addr)]);
           }
           else {
-            trigger(Event:L1_WBDIRTYDATA, in_msg.Address,
-                    cache_entry, TBEs[in_msg.Address]);
+            trigger(Event:L1_WBDIRTYDATA, in_msg.Addr,
+                    cache_entry, TBEs[in_msg.Addr]);
           }
         } else if (in_msg.Type == CoherenceResponseType:WRITEBACK_CLEAN_DATA) {
-          Entry cache_entry := getCacheEntry(in_msg.Address);
+          Entry cache_entry := getCacheEntry(in_msg.Addr);
           if (is_invalid(cache_entry) &&
-                   L2cache.cacheAvail(in_msg.Address) == false) {
-            trigger(Event:L2_Replacement, L2cache.cacheProbe(in_msg.Address),
-                    getCacheEntry(L2cache.cacheProbe(in_msg.Address)),
-                    TBEs[L2cache.cacheProbe(in_msg.Address)]);
+                   L2cache.cacheAvail(in_msg.Addr) == false) {
+            trigger(Event:L2_Replacement, L2cache.cacheProbe(in_msg.Addr),
+                    getCacheEntry(L2cache.cacheProbe(in_msg.Addr)),
+                    TBEs[L2cache.cacheProbe(in_msg.Addr)]);
           }
           else {
-            trigger(Event:L1_WBCLEANDATA, in_msg.Address,
-                    cache_entry, TBEs[in_msg.Address]);
+            trigger(Event:L1_WBCLEANDATA, in_msg.Addr,
+                    cache_entry, TBEs[in_msg.Addr]);
           }
         } else if (in_msg.Type == CoherenceResponseType:DMA_ACK) {
-          trigger(Event:DmaAck, in_msg.Address,
-                  getCacheEntry(in_msg.Address), TBEs[in_msg.Address]);
+          trigger(Event:DmaAck, in_msg.Addr,
+                  getCacheEntry(in_msg.Addr), TBEs[in_msg.Addr]);
         } else {
           error("Unexpected message");
         }
@@ -684,7 +684,7 @@ machine(L2Cache, "Token protocol")
   action(a_issueGETS, "a", desc="issue local request globally") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue(globalRequestNetwork_out, RequestMsg, latency=request_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceRequestType:GETS;
         out_msg.RequestorMachine := MachineType:L2Cache;
         out_msg.Requestor := machineID;
@@ -697,7 +697,7 @@ machine(L2Cache, "Token protocol")
   action(a_issueGETX, "\a", desc="issue local request globally") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue(globalRequestNetwork_out, RequestMsg, latency=request_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceRequestType:GETX;
         out_msg.RequestorMachine := MachineType:L2Cache;
         out_msg.Requestor := machineID;
@@ -709,7 +709,7 @@ machine(L2Cache, "Token protocol")
 
   action(b_issuePUTX, "b", desc="Issue PUTX") {
     enqueue(globalRequestNetwork_out, RequestMsg, latency=request_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceRequestType:PUTX;
       out_msg.RequestorMachine := MachineType:L2Cache;
       out_msg.Requestor := machineID;
@@ -720,7 +720,7 @@ machine(L2Cache, "Token protocol")
 
   action(b_issuePUTO, "\b", desc="Issue PUTO") {
     enqueue(globalRequestNetwork_out, RequestMsg, latency=request_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceRequestType:PUTO;
       out_msg.Requestor := machineID;
       out_msg.RequestorMachine := MachineType:L2Cache;
@@ -732,7 +732,7 @@ machine(L2Cache, "Token protocol")
   /* PUTO, but local sharers exist */
   action(b_issuePUTO_ls, "\bb", desc="Issue PUTO") {
     enqueue(globalRequestNetwork_out, RequestMsg, latency=request_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceRequestType:PUTO_SHARERS;
       out_msg.Requestor := machineID;
       out_msg.RequestorMachine := MachineType:L2Cache;
@@ -744,7 +744,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendDataFromTBEToL1GETS, "c", desc="Send data from TBE to L1 requestors in TBE") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:DATA;
       out_msg.Sender := machineID;
       out_msg.Destination.addNetDest(tbe.L1_GetS_IDs);
@@ -761,7 +761,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendDataFromTBEToL1GETX, "\c", desc="Send data from TBE to L1 requestors in TBE") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -778,7 +778,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendExclusiveDataFromTBEToL1GETS, "\cc", desc="Send data from TBE to L1 requestors in TBE") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -792,7 +792,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendDataFromTBEToFwdGETX, "cc", desc="Send data from TBE to external GETX") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -808,7 +808,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(tbe));
     peek(requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -827,7 +827,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendDataFromTBEToFwdGETS, "ccc", desc="Send data from TBE to external GETX") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:DATA;
       out_msg.Sender := machineID;
       out_msg.Destination.addNetDest(tbe.Fwd_GetS_IDs);
@@ -845,7 +845,7 @@ machine(L2Cache, "Token protocol")
   action(c_sendExclusiveDataFromTBEToFwdGETS, "\ccc", desc="Send data from TBE to external GETX") {
     assert(is_valid(tbe));
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -863,7 +863,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -883,7 +883,7 @@ machine(L2Cache, "Token protocol")
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
         assert(is_valid(tbe));
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
         out_msg.Sender := machineID;
         out_msg.SenderMachine := MachineType:L2Cache;
@@ -902,7 +902,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     peek(requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
         out_msg.Sender := machineID;
         out_msg.SenderMachine := MachineType:L2Cache;
@@ -922,7 +922,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     peek(requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -941,7 +941,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(cache_entry));
     peek(requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:DATA_EXCLUSIVE;
         out_msg.Sender := machineID;
         out_msg.Destination.add(in_msg.Requestor);
@@ -955,7 +955,7 @@ machine(L2Cache, "Token protocol")
   action(e_sendAck, "e", desc="Send ack with the tokens we've collected thus far.") {
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
       assert(is_valid(tbe));
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:ACK;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -969,7 +969,7 @@ machine(L2Cache, "Token protocol")
   action(e_sendAckToL1Requestor, "\e", desc="Send ack with the tokens we've collected thus far.") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceResponseType:ACK;
         out_msg.Sender := machineID;
         out_msg.SenderMachine := MachineType:L2Cache;
@@ -983,7 +983,7 @@ machine(L2Cache, "Token protocol")
   action(e_sendAckToL1RequestorFromTBE, "eee", desc="Send ack with the tokens we've collected thus far.") {
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
       assert(is_valid(tbe));
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:ACK;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
@@ -1005,7 +1005,7 @@ machine(L2Cache, "Token protocol")
     }
 
     enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceRequestType:INV;
       out_msg.Requestor := machineID;
       out_msg.RequestorMachine := MachineType:L2Cache;
@@ -1026,7 +1026,7 @@ machine(L2Cache, "Token protocol")
 
     if (countLocalSharers(cache_entry, address) > 0) {
       enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceRequestType:INV;
         out_msg.Requestor := machineID;
         out_msg.RequestorMachine := MachineType:L2Cache;
@@ -1058,7 +1058,7 @@ machine(L2Cache, "Token protocol")
           }
 
           enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-            out_msg.Address := address;
+            out_msg.Addr := address;
             out_msg.Type := CoherenceRequestType:INV;
             out_msg.Requestor := in_msg.Requestor;
             out_msg.RequestorMachine := MachineType:L1Cache;
@@ -1084,7 +1084,7 @@ machine(L2Cache, "Token protocol")
       }
     }
     enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := CoherenceRequestType:INV;
         out_msg.Requestor := tbe.L1_GetX_ID;
         out_msg.RequestorMachine := MachineType:L1Cache;
@@ -1097,7 +1097,7 @@ machine(L2Cache, "Token protocol")
 
   action(f_sendUnblock, "f", desc="Send unblock to global directory") {
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:UNBLOCK;
       out_msg.Destination.add(map_Address_to_Directory(address));
       out_msg.Sender := machineID;
@@ -1109,7 +1109,7 @@ machine(L2Cache, "Token protocol")
 
   action(f_sendExclusiveUnblock, "\f", desc="Send unblock to global directory") {
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:UNBLOCK_EXCLUSIVE;
       out_msg.Destination.add(map_Address_to_Directory(address));
       out_msg.Sender := machineID;
@@ -1121,7 +1121,7 @@ machine(L2Cache, "Token protocol")
 
   action(g_recordLocalSharer, "g", desc="Record new local sharer from unblock message") {
     peek(responseNetwork_in, ResponseMsg) {
-      recordLocalSharerInDir(cache_entry, in_msg.Address, in_msg.Sender);
+      recordLocalSharerInDir(cache_entry, in_msg.Addr, in_msg.Sender);
     }
   }
 
@@ -1137,13 +1137,13 @@ machine(L2Cache, "Token protocol")
 
   action(gg_clearSharerFromL1Response, "\gg", desc="Clear sharer from L1 response queue") {
     peek(responseNetwork_in, ResponseMsg) {
-      removeSharerFromDir(cache_entry, in_msg.Address, in_msg.Sender);
+      removeSharerFromDir(cache_entry, in_msg.Addr, in_msg.Sender);
     }
   }
 
   action(gg_clearOwnerFromL1Response, "g\g", desc="Clear sharer from L1 response queue") {
     peek(responseNetwork_in, ResponseMsg) {
-      removeOwnerFromDir(cache_entry, in_msg.Address, in_msg.Sender);
+      removeOwnerFromDir(cache_entry, in_msg.Addr, in_msg.Sender);
     }
   }
 
@@ -1192,11 +1192,11 @@ machine(L2Cache, "Token protocol")
   action(j_forwardGlobalRequestToLocalOwner, "j", desc="Forward external request to local owner") {
     peek(requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-        out_msg.Address := in_msg.Address;
+        out_msg.Addr := in_msg.Addr;
         out_msg.Type := in_msg.Type;
         out_msg.Requestor := machineID;
         out_msg.RequestorMachine := MachineType:L2Cache;
-        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Address));
+        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Addr));
         out_msg.Type := in_msg.Type;
         out_msg.MessageSize := MessageSizeType:Forwarded_Control;
         out_msg.Acks := 0 - 1;
@@ -1207,11 +1207,11 @@ machine(L2Cache, "Token protocol")
   action(jd_forwardDmaRequestToLocalOwner, "jd", desc="Forward dma request to local owner") {
     peek(requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-        out_msg.Address := in_msg.Address;
+        out_msg.Addr := in_msg.Addr;
         out_msg.Type := in_msg.Type;
         out_msg.Requestor := in_msg.Requestor;
         out_msg.RequestorMachine := in_msg.RequestorMachine;
-        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Address));
+        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Addr));
         out_msg.Type := in_msg.Type;
         out_msg.MessageSize := MessageSizeType:Forwarded_Control;
         out_msg.Acks := 0 - 1;
@@ -1223,12 +1223,12 @@ machine(L2Cache, "Token protocol")
   action(k_forwardLocalGETSToLocalSharer, "k", desc="Forward local request to local sharer/owner") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-        out_msg.Address := in_msg.Address;
+        out_msg.Addr := in_msg.Addr;
         out_msg.Type := CoherenceRequestType:GETS;
         out_msg.Requestor := in_msg.Requestor;
         out_msg.RequestorMachine := MachineType:L1Cache;
         // should randomize this so one node doesn't get abused more than others
-        out_msg.Destination.add(localDirectory[in_msg.Address].Sharers.smallestElement(MachineType:L1Cache));
+        out_msg.Destination.add(localDirectory[in_msg.Addr].Sharers.smallestElement(MachineType:L1Cache));
         out_msg.MessageSize := MessageSizeType:Forwarded_Control;
       }
     }
@@ -1237,7 +1237,7 @@ machine(L2Cache, "Token protocol")
   action(k_forwardLocalGETXToLocalOwner, "\k", desc="Forward local request to local owner") {
     enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
       assert(is_valid(tbe));
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceRequestType:GETX;
       out_msg.Requestor := tbe.L1_GetX_ID;
       out_msg.RequestorMachine := MachineType:L1Cache;
@@ -1251,11 +1251,11 @@ machine(L2Cache, "Token protocol")
   action(kk_forwardLocalGETXToLocalExclusive, "kk", desc="Forward local request to local owner") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-        out_msg.Address := in_msg.Address;
+        out_msg.Addr := in_msg.Addr;
         out_msg.Type := CoherenceRequestType:GETX;
         out_msg.Requestor := in_msg.Requestor;
         out_msg.RequestorMachine := MachineType:L1Cache;
-        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Address));
+        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Addr));
         out_msg.MessageSize := MessageSizeType:Forwarded_Control;
         out_msg.Acks := 1;
       }
@@ -1265,11 +1265,11 @@ machine(L2Cache, "Token protocol")
   action(kk_forwardLocalGETSToLocalOwner, "\kk", desc="Forward local request to local owner") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-        out_msg.Address := in_msg.Address;
+        out_msg.Addr := in_msg.Addr;
         out_msg.Type := CoherenceRequestType:GETS;
         out_msg.Requestor := in_msg.Requestor;
         out_msg.RequestorMachine := MachineType:L1Cache;
-        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Address));
+        out_msg.Destination.add(getLocalOwner(cache_entry, in_msg.Addr));
         out_msg.MessageSize := MessageSizeType:Forwarded_Control;
       }
     }
@@ -1279,7 +1279,7 @@ machine(L2Cache, "Token protocol")
   action(l_writebackAckNeedData, "l", desc="Send writeback ack to L1 requesting data") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-        out_msg.Address := in_msg.Address;
+        out_msg.Addr := in_msg.Addr;
         // out_msg.Type := CoherenceResponseType:WRITEBACK_SEND_DATA;
         out_msg.Type := CoherenceRequestType:WB_ACK_DATA;
         out_msg.Requestor := machineID;
@@ -1293,7 +1293,7 @@ machine(L2Cache, "Token protocol")
   action(l_writebackAckDropData, "\l", desc="Send writeback ack to L1 indicating to drop data") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-        out_msg.Address := in_msg.Address;
+        out_msg.Addr := in_msg.Addr;
         // out_msg.Type := CoherenceResponseType:WRITEBACK_ACK;
         out_msg.Type := CoherenceRequestType:WB_ACK;
         out_msg.Requestor := machineID;
@@ -1307,7 +1307,7 @@ machine(L2Cache, "Token protocol")
   action(ll_writebackNack, "\ll", desc="Send writeback nack to L1") {
     peek(L1requestNetwork_in, RequestMsg) {
       enqueue( localRequestNetwork_out, RequestMsg, latency=response_latency ) {
-        out_msg.Address := in_msg.Address;
+        out_msg.Addr := in_msg.Addr;
         out_msg.Type := CoherenceRequestType:WB_NACK;
         out_msg.Requestor := machineID;
         out_msg.RequestorMachine := MachineType:L2Cache;
@@ -1359,7 +1359,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(tbe));
     if (tbe.NumIntPendingAcks == 0) {
       enqueue(triggerQueue_out, TriggerMsg) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := TriggerType:ALL_ACKS;
       }
     }
@@ -1369,7 +1369,7 @@ machine(L2Cache, "Token protocol")
     assert(is_valid(tbe));
     if (tbe.NumExtPendingAcks == 0) {
       enqueue(triggerQueue_out, TriggerMsg) {
-        out_msg.Address := address;
+        out_msg.Addr := address;
         out_msg.Type := TriggerType:ALL_ACKS;
       }
     }
@@ -1379,7 +1379,7 @@ machine(L2Cache, "Token protocol")
   action( qq_sendDataFromTBEToMemory, "qq", desc="Send data from TBE to directory") {
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
       assert(is_valid(tbe));
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Sender := machineID;
       out_msg.SenderMachine := MachineType:L2Cache;
       out_msg.Destination.add(map_Address_to_Directory(address));
@@ -1512,7 +1512,7 @@ machine(L2Cache, "Token protocol")
 
   action(da_sendDmaAckUnblock, "da", desc="Send dma ack to global directory") {
     enqueue(responseNetwork_out, ResponseMsg, latency=response_latency) {
-      out_msg.Address := address;
+      out_msg.Addr := address;
       out_msg.Type := CoherenceResponseType:DMA_ACK;
       out_msg.Destination.add(map_Address_to_Directory(address));
       out_msg.Sender := machineID;