Rename line number for readability

src/common/action.h

@@ -51,9 +51,9 @@ class Action {
   // Generates std::string representation of the action and stores in "buff".
   // It does not append '\n' at the end of. the std::string
   void printActionNN(std::ostringstream & buff) {
-    std::string type = " R ";
-    if ( is_write_action ) type = " W ";
-    buff << accessing_task_id << type <<  destination_address << " " << value_written
+    std::string action_type = " R ";
+    if ( is_write_action ) action_type = " W ";
+    buff << accessing_task_id << action_type <<  destination_address << " " << value_written
          << " " << source_line_num << " " << source_func_id;
   }
 

src/common/instruction.h

@@ -20,7 +20,7 @@
 
 class Instruction {
   public:
-  INTEGER lineNo;
+  INTEGER source_line_num;
   std::string destination;
   std::string type;
   OPERATION oper;
@@ -128,7 +128,7 @@ class Instruction {
   }
 
   void print() {
-    std::cout << "LineNo: " << lineNo
+    std::cout << "source_line_num: " << source_line_num
          << ", type: " << type
          << ", oper: " << OperRepresentation(oper)
          << ", dest: " << destination

src/detector/commutativity/CommutativityChecker.cc

@@ -29,14 +29,14 @@ VOID CommutativityChecker::parseTasksIR(char * IRlogName) {
 
     sttmt = Instruction::trim( sttmt );        // trim spaces
     if ( isValidStatement(sttmt) ) {           // check if normal statement
-      INTEGER lineNo = getLineNumber( sttmt );
+      INTEGER source_line_num = getLineNumber( sttmt );
       // skip instruction with line # 0: args to task body
-      if (lineNo <= 0) continue;
+      if (source_line_num <= 0) continue;
 
       sttmt = sttmt.substr(sttmt.find_first_not_of(' ',
                            sttmt.find_first_of(' ')));
       Instruction instr( sttmt );
-      instr.lineNo = lineNo;
+      instr.source_line_num = source_line_num;
       currentTask.push_back(instr);
       continue;
     } // if
@@ -87,8 +87,8 @@ BOOL CommutativityChecker::involveSimpleOperations(
   INTEGER index = -1;
 
   for (auto i = taskBody->begin(); i != taskBody->end(); i++) {
-     if (i->lineNo > lineNumber) break;
-     if (i->lineNo == lineNumber) instr  = *i;
+     if (i->source_line_num > lineNumber) break;
+     if (i->source_line_num == lineNumber) instr  = *i;
      index++;
   }
 

src/detector/commutativity/CriticalSectionBody.h

@@ -36,16 +36,16 @@ class CriticalSectionBody {
 
   CriticalSectionBody(std::vector<Instruction> _body) {
     if( _body.size() > 0 ) {
-      setStartLineNo( _body.front().lineNo );
-      setEndLineNo  ( _body.back().lineNo  );
+      setStartLineNo( _body.front().source_line_num );
+      setEndLineNo  ( _body.back().source_line_num  );
       body = _body;
     } else {
       throw "Critical section must contain at least one statement";
     }
   }
-  void   setStartLineNo(int lineNo) { startLineNo = lineNo; }
-  void   setEndLineNo(int lineNo) {
-    endLineNo = lineNo;
+  void   setStartLineNo(int source_line_num) { startLineNo = source_line_num; }
+  void   setEndLineNo(int source_line_num) {
+    endLineNo = source_line_num;
     assert(endLineNo >= startLineNo);
   }
   int    getStartLineNo()           { return startLineNo;   }

src/detector/commutativity/CriticalSections.h

@@ -39,19 +39,19 @@ class CriticalSections {
 
   size_t getSize() { return sections.size(); }
 
-  CriticalSectionBody *find(int lineNo) {
+  CriticalSectionBody *find(int source_line_num) {
     if (0 == sections.size()) return end();
 
     for (auto &cr : sections) {
-      if (cr.second.getStartLineNo() <= lineNo
-          && lineNo <= cr.second.getEndLineNo()) {
+      if (cr.second.getStartLineNo() <= source_line_num
+          && source_line_num <= cr.second.getEndLineNo()) {
         return &cr.second;
       }
     }
-    auto start = sections.lower_bound(lineNo);
+    auto start = sections.lower_bound(source_line_num);
     if (start == sections.end()) return end();
-    if ( lineNo >= start->second.getStartLineNo() &&
-        lineNo <= start->second.getEndLineNo() ) {
+    if ( source_line_num >= start->second.getStartLineNo() &&
+        source_line_num <= start->second.getEndLineNo() ) {
       return &start->second;
     }
 

src/functionengine/FunctionEngine.h

@@ -23,7 +23,7 @@
 
 class FunctionEngine {
   public:
-    void pushFunction(std::string name, unsigned taskID, int lineNo);
+    void pushFunction(std::string name, unsigned taskID, int source_line_num);
     void popFunction(std::string name, unsigned taskID);
     CallStack &getStack(unsigned taskID);
     void removeStack(unsigned taskID);

src/instrumentor/callbacks/InstrumentationCallbacks.cc

@@ -68,23 +68,23 @@ static TaskInfo * getTaskInfo(int * _type = NULL) {
 inline void INS_MemRead(
   address addr,
     ulong size,
-    int lineNo,
+    int source_line_num,
     address funcName) {
 
-  if (!lineNo) return;
+  if (!source_line_num) return;
 
   TaskInfo * taskInfo = getTaskInfo();
   //lint value = getMemoryValue( addr, size );
   //uint threadID = (uint)pthread_self();
 
   if ( taskInfo && taskInfo->active ) {
-    INS::Read(*taskInfo, addr, lineNo, (char*)funcName);
+    INS::Read(*taskInfo, addr, source_line_num, (char*)funcName);
 #ifdef DEBUG
     std::stringstream ss;
     ss << std::hex << addr;
     PRINT_DEBUG("READ: addr: " + ss.str() +
         " taskID: " + std::to_string(taskInfo->taskID) +
-        " line no: " + std::to_string(lineNo));
+        " line no: " + std::to_string(source_line_num));
 #endif
   }
 }
@@ -93,23 +93,23 @@ inline void INS_MemRead(
 inline void INS_MemWrite(
     address addr,
     lint value,
-    int lineNo,
+    int source_line_num,
     address funcName ) {
 
-  if (!lineNo) return;
+  if (!source_line_num) return;
 
   TaskInfo * taskInfo = getTaskInfo();
   //uint threadID = (uint)pthread_self();
 
   if ( taskInfo && taskInfo->active ) {
-    INS::Write(*taskInfo, addr, (lint)value, lineNo, (char*)funcName );
+    INS::Write(*taskInfo, addr, (lint)value, source_line_num, (char*)funcName );
 #ifdef DEBUG
     std::stringstream ss;
     ss << std::hex << addr;
     PRINT_DEBUG("= WRITE: addr: " + ss.str() +
         ", value: " + std::to_string((lint)value) +
         ", taskID: " + std::to_string(taskInfo->taskID) +
-        ", line number: " + std::to_string(lineNo) +
+        ", line number: " + std::to_string(source_line_num) +
         ", func name: " + std::string((char*)funcName));
 #endif
   }
@@ -119,9 +119,9 @@ inline void INS_MemWrite(
 void __tasksan_write_float(
     address addr,
     float value,
-    int lineNo,
+    int source_line_num,
     address funcName) {
-  INS_MemWrite(addr, (lint)value, lineNo, funcName);
+  INS_MemWrite(addr, (lint)value, source_line_num, funcName);
 }
 
 void __tasksan_register_iir_file(void * fileName) {
@@ -132,52 +132,52 @@ void __tasksan_register_iir_file(void * fileName) {
 void __tasksan_write_double(
     address addr,
     double value,
-    int lineNo,
+    int source_line_num,
     address funcName) {
-  INS_MemWrite(addr, (lint)value, lineNo, funcName);
+  INS_MemWrite(addr, (lint)value, source_line_num, funcName);
 }
 
 void __tasksan_flush_memory() {
   PRINT_DEBUG("  TaskSanitizer: flush memory");
 }
 
-void __tasksan_read1(void *addr, int lineNo, address funcName) {
-  INS_MemRead(addr, 1, lineNo, funcName);
+void __tasksan_read1(void *addr, int source_line_num, address funcName) {
+  INS_MemRead(addr, 1, source_line_num, funcName);
 }
-void __tasksan_read2(void *addr, int lineNo, address funcName) {
-  INS_MemRead(addr, 2, lineNo, funcName);
+void __tasksan_read2(void *addr, int source_line_num, address funcName) {
+  INS_MemRead(addr, 2, source_line_num, funcName);
 }
 
-void __tasksan_read4(void *addr, int lineNo, address funcName) {
-  INS_MemRead(addr, 4, lineNo, funcName);
+void __tasksan_read4(void *addr, int source_line_num, address funcName) {
+  INS_MemRead(addr, 4, source_line_num, funcName);
 }
 
-void __tasksan_read8(void *addr, int lineNo, address funcName) {
-  INS_MemRead( addr, 8, lineNo, funcName );
+void __tasksan_read8(void *addr, int source_line_num, address funcName) {
+  INS_MemRead( addr, 8, source_line_num, funcName );
 }
 
-void __tasksan_read16(void *addr, int lineNo, address funcName) {
-  INS_MemRead( addr, 16, lineNo, funcName );
+void __tasksan_read16(void *addr, int source_line_num, address funcName) {
+  INS_MemRead( addr, 16, source_line_num, funcName );
 }
 
-void __tasksan_write1(void *addr, lint value, int lineNo, address funcName) {
-  INS_MemWrite((address)addr, value, lineNo, funcName);
+void __tasksan_write1(void *addr, lint value, int source_line_num, address funcName) {
+  INS_MemWrite((address)addr, value, source_line_num, funcName);
 }
 
-void __tasksan_write2(void *addr, lint value, int lineNo, address funcName) {
-  INS_MemWrite((address)addr, value, lineNo, funcName);
+void __tasksan_write2(void *addr, lint value, int source_line_num, address funcName) {
+  INS_MemWrite((address)addr, value, source_line_num, funcName);
 }
 
-void __tasksan_write4(void *addr, lint value, int lineNo, address funcName) {
-  INS_MemWrite((address)addr, value, lineNo, funcName);
+void __tasksan_write4(void *addr, lint value, int source_line_num, address funcName) {
+  INS_MemWrite((address)addr, value, source_line_num, funcName);
 }
 
-void __tasksan_write8(void *addr, lint value, int lineNo, address funcName) {
-  INS_MemWrite((address)addr, value, lineNo, funcName);
+void __tasksan_write8(void *addr, lint value, int source_line_num, address funcName) {
+  INS_MemWrite((address)addr, value, source_line_num, funcName);
 }
 
-void __tasksan_write16(void *addr, lint value, int lineNo, address funcName) {
-  INS_MemWrite((address)addr, value, lineNo, funcName);
+void __tasksan_write16(void *addr, lint value, int source_line_num, address funcName) {
+  INS_MemWrite((address)addr, value, source_line_num, funcName);
 }
 
 void __tasksan_unaligned_read2(const void *addr) {

src/instrumentor/callbacks/InstrumentationCallbacks.h

@@ -42,9 +42,9 @@ extern "C" {
                         unsigned long size);
 
   // callbacks for memory access, race detection
-  void INS_MemRead8(void *addr, int lineNo, void *fName);
-  void INS_MemRead4(void *addr, int lineNo, void *fName);
-  void INS_MemRead1(void *addr, int lineNo, void *fName);
+  void INS_MemRead8(void *addr, int source_line_num, void *fName);
+  void INS_MemRead4(void *addr, int source_line_num, void *fName);
+  void INS_MemRead1(void *addr, int source_line_num, void *fName);
   void INS_MemWrite8(void *addr, long int v, int lnNo, void *fName);
   void INS_MemWrite4(void *addr, long int v, int lnNo, void *fName);
   void INS_MemWrite1(void *addr, long int v, int lnNo, void *fName);
@@ -74,17 +74,17 @@ extern "C" {
 
   void __tasksan_flush_memory();
 
-  void __tasksan_read1(void *addr, int lineNo, address funcName);
-  void __tasksan_read2(void *addr, int lineNo, address funcName);
-  void __tasksan_read4(void *addr, int lineNo, address funcName);
-  void __tasksan_read8(void *addr, int lineNo, address funcName);
-  void __tasksan_read16(void *addr, int lineNo, address funcName);
-
-  void __tasksan_write1(void *addr, long int value, int lineNo, address funcName);
-  void __tasksan_write2(void *addr, long int value, int lineNo, address funcName);
-  void __tasksan_write4(void *addr, long int value, int lineNo, address funcName);
-  void __tasksan_write8(void *addr, long int value, int lineNo, address funcName);
-  void __tasksan_write16(void *addr, long int value, int lineNo, address funcName);
+  void __tasksan_read1(void *addr, int source_line_num, address funcName);
+  void __tasksan_read2(void *addr, int source_line_num, address funcName);
+  void __tasksan_read4(void *addr, int source_line_num, address funcName);
+  void __tasksan_read8(void *addr, int source_line_num, address funcName);
+  void __tasksan_read16(void *addr, int source_line_num, address funcName);
+
+  void __tasksan_write1(void *addr, long int value, int source_line_num, address funcName);
+  void __tasksan_write2(void *addr, long int value, int source_line_num, address funcName);
+  void __tasksan_write4(void *addr, long int value, int source_line_num, address funcName);
+  void __tasksan_write8(void *addr, long int value, int source_line_num, address funcName);
+  void __tasksan_write16(void *addr, long int value, int source_line_num, address funcName);
 
   void __tasksan_unaligned_read2(const void *addr);
   void __tasksan_unaligned_read4(const void *addr);

src/instrumentor/eventlogger/Logger.h

@@ -182,7 +182,7 @@ class INS {
 
     // provides the address of memory a task reads from
     static inline VOID Read( TaskInfo & task,
-        ADDRESS addr, INTEGER lineNo, STRING funcName ) {
+        ADDRESS addr, INTEGER source_line_num, STRING funcName ) {
       INTEGER funcID = task.getFunctionId( funcName );
 
       // register function if not registered yet
@@ -191,9 +191,9 @@ class INS {
         task.registerFunction( funcName, funcID );
       }
 
-      //task.saveReadAction(addr, lineNo, funcID);
+      //task.saveReadAction(addr, source_line_num, funcID);
       std::stringstream ssin(std::to_string((VALUE)addr) + " 0 " +
-          std::to_string(lineNo) + " " + std::to_string(funcID));
+          std::to_string(source_line_num) + " " + std::to_string(funcID));
 
       guardLock.lock();
       onlineChecker.detectRaceOnMem(task.taskID, "R", ssin);
@@ -202,7 +202,7 @@ class INS {
 
     // stores a write action
     static inline VOID Write(TaskInfo & task, ADDRESS addr,
-        INTEGER value, INTEGER lineNo, STRING funcName) {
+        INTEGER value, INTEGER source_line_num, STRING funcName) {
 
       INTEGER funcID = task.getFunctionId( funcName );
 
@@ -212,9 +212,9 @@ class INS {
         task.registerFunction( funcName, funcID );
       }
 
-      //task.saveWriteAction(addr, value, lineNo, funcID);
+      //task.saveWriteAction(addr, value, source_line_num, funcID);
       std::stringstream ssin(std::to_string((VALUE)addr) + " " +
-          std::to_string(value) + " " + std::to_string(lineNo) +
+          std::to_string(value) + " " + std::to_string(source_line_num) +
           " " + std::to_string(funcID));
 
       guardLock.lock();

src/instrumentor/eventlogger/TaskInfo.h

@@ -49,12 +49,12 @@ typedef struct TaskInfo {
   }
 
   inline void saveReadAction(ADDRESS & addr,
-      INTEGER & lineNo,
+      INTEGER & source_line_num,
       const INTEGER funcID) {
 
     MemoryActions & loc = memoryLocations[addr];
     if ( !loc.hasWrite() ) {
-      Action action( taskID, addr, 0, lineNo, funcID );
+      Action action( taskID, addr, 0, source_line_num, funcID );
       action.is_write_action = false;
       loc.storeAction( action );
     }
@@ -63,12 +63,12 @@ typedef struct TaskInfo {
   inline void saveWriteAction(
       ADDRESS addr,
       INTEGER value,
-      INTEGER lineNo,
+      INTEGER source_line_num,
       INTEGER funcID) {
 
      MemoryActions & loc = memoryLocations[addr];
      bool is_write_action = true;
-     loc.storeAction(taskID, addr, value, lineNo, funcID, is_write_action);
+     loc.storeAction(taskID, addr, value, source_line_num, funcID, is_write_action);
   }
 
   // Prints to ostringstream all memory access actions recorded.