Omit a formal parameter whose location contains an unsupported DWARF operation

valgrind/fjalar/basic-tool/basic-tool.c

@@ -94,6 +94,7 @@ void fjalar_tool_handle_function_entrance(FunctionExecutionState* f_state) {
                      0,
                      1,
                      0, 0,
+                     0,
                      &basicAction);
 
   VG_(printf)("  Function formal parameters:\n");
@@ -104,6 +105,7 @@ void fjalar_tool_handle_function_entrance(FunctionExecutionState* f_state) {
 		     (Addr)f_state->virtualStack
 		       + f_state->virtualStackFPOffset,
                      f_state->FP,
+                     f_state->entryRegs,
                      &basicAction);
 }
 
@@ -116,6 +118,7 @@ void fjalar_tool_handle_function_exit(FunctionExecutionState* f_state) {
                      0,
                      0,
                      0, 0,
+                     0,
                      &basicAction);
 
   VG_(printf)("  Function formal parameters:\n");
@@ -126,6 +129,7 @@ void fjalar_tool_handle_function_exit(FunctionExecutionState* f_state) {
 		     (Addr)f_state->virtualStack
 		       + f_state->virtualStackFPOffset,
                      f_state->FP,
+                     f_state->entryRegs,
                      &basicAction);
 
   VG_(printf)("  Return value:\n");

valgrind/fjalar/disambig.c

@@ -206,6 +206,7 @@ void generateDisambigFile() {
                      0,
                      0,
                      0,
+                     0,
                      &printDisambigAction);
 
   FJALAR_DPRINTF("=> generateDisambigFile: Finished Globals\n\n");
@@ -239,13 +240,15 @@ void generateDisambigFile() {
                          0,
                          0,
                          0,
+                         0,
                          &printDisambigAction);
 
       visitVariableGroup(FUNCTION_RETURN_VAR,
                          cur_entry,
                          0,
                          0,
                          0,
+                         0,
                          &printDisambigAction);
 
       fputs("\n", disambig_fp);

valgrind/fjalar/dwarf.c

@@ -1451,6 +1451,14 @@ decode_location_expression (unsigned char * data,
 
       if(ll) {ll->atom = op;}
 
+      /* An op that Fjalar's evaluator cannot apply, such as an unreadable register,
+	 DW_OP_stack_value, or DW_OP_plus (the evaluator has no operand
+	 stack), makes a formal parameter's location unreadable.
+	 DW_OP_piece is handled below.  */
+      if (ok_to_harvest && op != DW_OP_nop && op != DW_OP_piece
+	  && !location_op_is_supported (op))
+	harvest_formal_param_location_unsupported (entry);
+
       switch (op)
 	{
 	case DW_OP_addr:
@@ -1469,10 +1477,20 @@ decode_location_expression (unsigned char * data,
 	  break;
 	case DW_OP_const1u:
 	  SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
+	  if (ok_to_harvest)
+	    if (entry && tag_is_formal_parameter(entry->tag_name)) {
+	      harvest_formal_param_location_atom(entry, op, uvalue);
+	      harvest_formal_param_location_offset(entry, uvalue);
+	    }
 	  printf ("DW_OP_const1u: %lu", (unsigned long) uvalue);
 	  break;
 	case DW_OP_const1s:
 	  SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end);
+	  if (ok_to_harvest)
+	    if (entry && tag_is_formal_parameter(entry->tag_name)) {
+	      harvest_formal_param_location_atom(entry, op, svalue);
+	      harvest_formal_param_location_offset(entry, svalue);
+	    }
 	  printf ("DW_OP_const1s: %ld", (long) svalue);
 	  break;
 	case DW_OP_const2u:
@@ -1512,16 +1530,22 @@ decode_location_expression (unsigned char * data,
 	  printf ("DW_OP_const4s: %ld", (long) svalue);
 	  break;
 	case DW_OP_const8u:
-	  SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
-	  printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue);
-	  SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
-	  printf ("%lu", (unsigned long) uvalue);
+	  SAFE_BYTE_GET_AND_INC (uvalue, data, 8, end);
+	  if (ok_to_harvest)
+	    if (entry && tag_is_formal_parameter(entry->tag_name)) {
+	      harvest_formal_param_location_atom(entry, op, uvalue);
+	      harvest_formal_param_location_offset(entry, uvalue);
+	    }
+	  printf ("DW_OP_const8u: %s", dwarf_vmatoa ("u", uvalue));
 	  break;
 	case DW_OP_const8s:
-	  SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
-	  printf ("DW_OP_const8s: %ld ", (long) svalue);
-	  SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
-	  printf ("%ld", (long) svalue);
+	  SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 8, end);
+	  if (ok_to_harvest)
+	    if (entry && tag_is_formal_parameter(entry->tag_name)) {
+	      harvest_formal_param_location_atom(entry, op, svalue);
+	      harvest_formal_param_location_offset(entry, svalue);
+	    }
+	  printf ("DW_OP_const8s: %s", dwarf_vmatoa ("d", svalue));
 	  break;
 	case DW_OP_constu:
 	  READ_ULEB (uvalue, data, end);
@@ -1809,6 +1833,17 @@ decode_location_expression (unsigned char * data,
 	  break;
 	case DW_OP_piece:
 	  READ_ULEB (uvalue, data, end);
+	  /* Fjalar can read a location that consists of one piece, if that
+	     piece is the whole parameter; extractOneFormalParameterVar
+	     checks the size.  A piece that is not the last op means that
+	     the parameter is split.  A piece of size 0 covers no bytes.  */
+	  if (ok_to_harvest)
+	    {
+	      if (data == end && uvalue != 0)
+		harvest_formal_param_location_piece (entry, uvalue);
+	      else
+		harvest_formal_param_location_unsupported (entry);
+	    }
 	  printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue));
 	  break;
 	case DW_OP_deref_size:
@@ -3821,6 +3856,10 @@ read_and_display_attr_value (unsigned long           attribute,
           if (ok_to_harvest) {
               // frame base location list
               harvest_frame_base(entry, DW_OP_list, uvalue);
+              // Fjalar does not evaluate a location list for a formal
+              // parameter, so it cannot read the parameter.
+              if (attribute == DW_AT_location)
+                harvest_formal_param_location_unsupported(entry);
           }
           printf ("(");
           printf ("location list");
@@ -9710,6 +9749,14 @@ regname (unsigned int regno, int name_only_p)
   return reg;
 }
 
+/* Returns the name of DWARF register REGNO, for Fjalar's debugging
+   output.  */
+const char *
+dwarf_reg_name (unsigned int regno)
+{
+  return regname (regno, 1);
+}
+
 static void
 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
 {

valgrind/fjalar/fjalar_dwarf.c

@@ -336,3 +336,21 @@ location_expression_to_string(enum dwarf_location_atom op) {
     return(0);    // to stop compiler warning
   }
 }
+
+// Returns true if Fjalar's location evaluator (in visitVariableGroup) applies
+// op.  A register operation (DW_OP_reg* or DW_OP_breg*) is supported only if
+// Fjalar can read the register; Fjalar saves such a register, with its A and
+// V bits and DynComp tags, at function entrance.  extractOneFormalParameterVar
+// further restricts which locations that use DW_OP_reg* it accepts.
+int location_op_is_supported(unsigned int op) {
+  if ((op >= DW_OP_breg0) && (op <= DW_OP_breg31)) {
+    return (op - DW_OP_breg0) < FJALAR_NUM_DWARF_REGS;
+  }
+  if ((op >= DW_OP_reg0) && (op <= DW_OP_reg31)) {
+    return (op - DW_OP_reg0) < FJALAR_NUM_DWARF_REGS;
+  }
+  return ((op == DW_OP_deref)
+          || ((op >= DW_OP_const1u) && (op <= DW_OP_consts))
+          || (op == DW_OP_plus_uconst)
+          || (op == DW_OP_fbreg));
+}

valgrind/fjalar/fjalar_dwarf.h

@@ -41,4 +41,17 @@ typedef struct _dwarf_location {
 // A conversion between DWARF location atoms and a string representation
 const char* location_expression_to_string(enum dwarf_location_atom op);
 
+// One more than the largest DWARF register number that Fjalar can
+// read.
+#if defined(VGA_amd64)
+#define FJALAR_NUM_DWARF_REGS 16
+#else
+#define FJALAR_NUM_DWARF_REGS 9
+#endif
+
+// Returns true if visitVariableGroup can evaluate op in the location
+// expression of a formal parameter.  decode_location_expression
+// records every such op in the formal parameter's dwarf_stack.
+int location_op_is_supported(unsigned int op);
+
 #endif /* FJALAR_DWARF_H */

valgrind/fjalar/fjalar_include.h

@@ -402,6 +402,11 @@ typedef struct _VariableEntry {
   // location information will have validLoc = False
   Bool validLoc;
 
+  // True if the DWARF information gives a location that Fjalar cannot
+  // read (see location_has_unsupported_op in typedata.h).  Then
+  // validLoc is False and location_expression is empty.
+  Bool locationUnsupported;
+
   // In some situations (The primary one being dealing with the
   // formal parameters to main - see the MAIN STACK LAYOUT comment
   // in fjalar_traversal.c for more information) the location of
@@ -690,6 +695,12 @@ typedef struct _FunctionEntry {
 
   UInt nonce;
 
+  // Bit N is set if the valid location of some formal parameter uses
+  // DWARF register N (via DW_OP_regN or DW_OP_bregN) and Fjalar can
+  // read that register.  Fjalar saves those registers at function
+  // entrance in FunctionExecutionState.entryRegs.
+  UInt entryRegsMask;
+
 } FunctionEntry;
 
 
@@ -740,6 +751,36 @@ These data structures and functions provide mechanisms for runtime
 traversals within data structures and arrays
 **********************************************************************/
 
+#if defined(VGA_amd64)
+// The DWARF register number of the frame pointer
+#define DWARF_FP_REG 6
+#else
+// The DWARF register number of the frame pointer
+#define DWARF_FP_REG 5
+#endif
+
+// FJALAR_NUM_DWARF_REGS is defined in fjalar_dwarf.h.
+
+// If atom is DW_OP_regN or DW_OP_bregN, sets *regNum to N and returns
+// True.  Otherwise, returns False.
+Bool dwarf_op_reg_num(UInt atom, UInt* regNum);
+
+// Returns true if Fjalar can read the register with the given DWARF
+// register number.
+Bool dwarf_reg_is_readable(UInt regNum);
+
+// Returns the guest-state offset of the register with the given DWARF
+// register number, which must be readable.
+Int dwarf_reg_guest_offset(UInt regNum);
+
+// Returns the current value of the register with the given DWARF
+// register number, which must be readable.
+Addr read_dwarf_reg(ThreadId tid, UInt regNum);
+
+// Returns the name of the register with the given DWARF register
+// number, for debugging output (defined in dwarf.c).
+const HChar* dwarf_reg_name(UInt regNum);
+
 // Entries for tracking the runtime state of functions at entrances
 // and exits (used mainly by FunctionExecutionStateStack in
 // fjalar_main.c).  This class CANNOT BE SUBCLASSED because it is
@@ -789,8 +830,25 @@ typedef struct {
   // should be invisible to the calling function anyways.
   char* virtualStack;
   int virtualStackByteSize; // Number of 1-byte entries in virtualStack
+  // Number of bytes in the allocation that starts at virtualStack,
+  // which also contains entryRegs
+  int allocByteSize;
   int virtualStackFPOffset; // Where in the stack the frame pointer was
 
+  // The values at function entrance of the registers, indexed by
+  // DWARF register number:  entryRegs[N] holds register N, if bit N
+  // of func->entryRegsMask is set.  A formal parameter whose location is a
+  // register (DW_OP_reg*) is read from here, and the address of one
+  // whose location is relative to a register (DW_OP_breg*) is computed
+  // from here, at both entrance and exit, for the same reason as
+  // virtualStack:  the function body and epilogue may change the
+  // registers.  At function entrance,
+  // Fjalar copies those registers, with their A and V bits and
+  // DynComp tags, to entryRegs.  entryRegs has FJALAR_NUM_DWARF_REGS
+  // elements and lies in the same allocation as virtualStack, just
+  // after it; it is null if func->entryRegsMask is 0.
+  Addr* entryRegs;
+
 
   Addr lowSP;
 } FunctionExecutionState;
@@ -955,6 +1013,12 @@ void visitVariableGroup(VariableOrigin varOrigin,
                         // address space (it's what we'll dereference)
                         Addr stackBaseAddr,
                         Addr stackBaseAddrGuest,
+                        // The values of the registers at function
+                        // entrance, which is
+                        // FunctionExecutionState.entryRegs (only
+                        // used for varOrigin == FUNCTION_FORMAL_PARAM
+                        // and if stackBaseAddr is non-zero)
+                        Addr* entryRegs,
                         // This function performs an action for each
                         // variable visited:
                         TraversalAction *performAction);