valgrind_object.cpp

Linux平台下的内核及程序调试器

   case EM_WARNS:
   case GEN_SUPP:
   case ERROR_LIMIT:
   case DB_COMMAND:
   case DB_ATTACH:
      /* Note: gui option disabled, so only reaches here from cmdline */
      errval = PERROR_BADOPT;
      vkPrintErr("Option disabled '--%s'", opt->m_longFlag.latin1());
      vkPrintErr(" - Valgrind presets these options for XML output.");
      vkPrintErr(" - See valgrind/docs/internals/xml_output.txt.");
      break;

   case XML_COMMENT:
      /* don't wan't xml in comment: escape '<','&',etc */
      argval = escapeEntities( argval );
      break;

   case SUPPS_DIRS: {  /* not popt: only reaches here from gui */
      /* check all entries are valid dirs */
      QStringList dirs = QStringList::split(sep, argval);
      QStringList::iterator it = dirs.begin();
      for (; it != dirs.end(); ++it) {
         /* check dirs ok */
         *it = dirCheck( &errval, *it, true, false );
         if ( errval != PARSED_OK )
            break;
      }
      argval = dirs.join(sep);
   } break;

   case SUPPS_AVAIL:  /* not popt: only reaches here from gui */
   case SUPPS_SEL: {  /* is popt: --suppressions */
      QStringList files = QStringList::split(sep, argval);
      QStringList::iterator it = files.begin();
      for (; it != files.end(); ++it) {
         /* check files ok & readable */
         *it = fileCheck( &errval, *it, true, false );
         if ( errval != PARSED_OK )
            break;
         /* TODO: do we care if it doesn't end in .supp?
            - breaks the suppression widgets a little, as only lists those ending in .supp ... */

         /* TODO: ? check valid suppression files */
      }
      argval = files.join(sep);
   } break;

   case TRACE_CH: {
#if 0
      if ( opt->isValidArg( &errval, argval ) ) {
         if ( argval == "yes" ) {
            if ( vkConfig->rdBool( "db-attach", "valgrind" ) )
               errval = PERROR_DB_CONFLICT;
         }
      }
#else
      /* Disabled for now - can't deal with the multiple xml files this generates */
      /* Note: Also disabled in ValgrindOptionsPage() */
      errval = PERROR_BADOPT;
      vkPrintErr("Option disabled '--%s'", opt->m_longFlag.latin1());
      vkPrintErr(" - Valkyrie can't yet handle the multiple xml files this generates.");
#endif
   } break;


   case XML_OUTPUT:
      /* Note: gui option disabled, so only reaches here from cmdline */
      errval = PERROR_BADOPT;
      vkPrintErr("Option disabled '--%s'", opt->m_longFlag.latin1());
      vkPrintErr(" - Valkyrie always requires xml output from Valgrind.");
      break;


#if 0 // TODO: Fix Valgrind to allow gdb attaching with XML output
   case DB_COMMAND: {   /* gdb -nw %f %p */
      int pos = argval.find( ' ' );
      QString tmp = argval.left( pos );
      argval = binaryCheck( &errval, tmp );
      argval += tmp.right( tmp.length() - pos+1 );
      // vkPrint("db_command: %s", argval.latin1() );
   } break;

   /* check for conflict with --trace-children */
   case DB_ATTACH:
      if ( opt->isValidArg( &errval, argval ) ) {
         if ( argval == "yes" ) {
            if ( vkConfig->rdBool( "trace-children","valgrind" ) )
               errval = PERROR_DB_CONFLICT;
         }
      } break;
#endif

   case KERN_VAR:
      break;

   /* logging options */
   /* for all tools we use --log-file-exactly=xyz.
      this is set in Valkyrie::runTool(), and updated by the tool.
      all logging options are therefore ignored */
   case LOG_FILE:
   case LOG_FD:
   case LOG_PID:
   case LOG_QUAL:
   case LOG_SOCKET:
      /* Note: gui options disabled, so only reaches here from cmdline */
      errval = PERROR_BADOPT;
      vkPrintErr("Option disabled '--%s'", opt->m_longFlag.latin1());
      vkPrintErr(" - Valkyrie sets its own logging options to gather data from Valgrind.");
      break;


   /* Not yet implemented */
   case INPUT_FD:
      /* Note: gui option disabled, so only reaches here from cmdline */
      errval = PERROR_BADOPT;
      vkPrintErr("Option disabled '--%s'", opt->m_longFlag.latin1());
      vkPrintErr(" - Not yet implemented.");
      break;

   default:
      vk_assert_never_reached();
   }

   return errval;
}


/* valkyrie hijacks any log-to-file flags; these are not passed to
   valgrind, but are used after parsing has finished to save to. */
QStringList Valgrind::modifiedVgFlags( const ToolObject* tool_obj )
{
   QStringList modFlags;
   QString defVal, cfgVal, flag;

   for ( Option* opt = m_optList.first(); opt; opt = m_optList.next() ) {
      flag = opt->m_longFlag.isEmpty() ? opt->m_shortFlag
                                       : opt->m_longFlag;
      defVal = opt->m_defaultValue;
      cfgVal = vkConfig->rdEntry( opt->cfgKey(), name() );

      switch ( (Valgrind::vgOpts)opt->m_key ) {

      /* we never want these included */
      case TOOL:            /* tool set by valkyrie */
      case SUPPS_DIRS:      /* false option */
      case SUPPS_AVAIL:     /* false option */
         break;

      /* only error-reporting tools have suppressions */
      case SUPPS_SEL: {
         if ( tool_obj->name() == "memcheck" ) {
            /* we need '--suppressions=' before each and every filename */
            QString optEntry = vkConfig->rdEntry( opt->cfgKey(), name() );
            QStringList files = QStringList::split( ",", optEntry );
            for ( unsigned int i=0; i<files.count(); i++ ) {
               modFlags << "--" + opt->cfgKey() + "=" + files[i];
            }
         }
      } break;


      /* for memcheck we always need xml=yes */
      case XML_OUTPUT:
         if ( tool_obj->name() == "memcheck")
            modFlags << "--" + opt->cfgKey() + "=yes";
         else
            if ( defVal != cfgVal )
               modFlags << "--" + opt->cfgKey() + "=" + cfgVal;
         break;

      case VERBOSITY:
      case TRACK_FDS:
      case TIME_STAMP:
      case EM_WARNS:
      case GEN_SUPP:
      case ERROR_LIMIT:
      case DB_ATTACH:
      case DB_COMMAND:
         if ( defVal != cfgVal ) {
            // disabled for now: /* gui options not disabled: other tools use these options */
            if ( tool_obj->name() == "memcheck") {
               /* memcheck presets/ignores these options for xml output
                  - ignore these opts
                  - see valgrind/docs/internals/xml_output.txt */
            } else {
               modFlags << "--" + opt->cfgKey() + "=" + cfgVal;
            }
         }
         break;

      /* for all tools we use --log-file-exactly=xyz.
         this is set in Valkyrie::runTool(), and updated by the tool.
         all logging options should therefore not be used */
      case LOG_FILE:
      case LOG_FD:
      case LOG_PID:
      case LOG_QUAL:
      case LOG_SOCKET:
         /* ignore these opts */
         break;

      default:
         if ( defVal != cfgVal ) {
            modFlags << "--" + opt->cfgKey() + "=" + cfgVal;
         }
         break;
      }
   }

   return modFlags;
}




/* Register tools */
void Valgrind::initToolObjects()
{ 
   int objId = VkObject::ID_TOOL0;
   m_toolObjList.append( new Memcheck  ( objId++ ) );

   // TODO: I need another lifetime!
//   m_toolObjList.append( new Cachegrind( objId++ ) );
//   m_toolObjList.append( new Massif    ( objId++ ) );
}


/* ToolObject access -------------------------------------------=---- */ 

/* Returns a list of all ptrs to ToolObjects */
ToolObjList Valgrind::toolObjList()
{
   return m_toolObjList;
}

/* Returns a ToolObject's objectId based on its name */
int Valgrind::toolObjId( const QString& name )
{
   return toolObj(name)->objId();
}

/* Returns a ToolObject based on its objectId */
ToolObject* Valgrind::toolObj( int tid )
{
   //   vkPrint("Valgrind::toolObj( int tid=%d )", tid);
   vk_assert( tid >= ID_TOOL0 );
   ToolObject* tool = m_toolObjList.at( tid - ID_TOOL0 );
   vk_assert( tool != 0 );
   vk_assert( tool->objId() == tid );
   return tool;
}

/* Returns a ToolObject based on its name */
ToolObject* Valgrind::toolObj( const QString& name ) {
   ToolObject* tool;
   for ( tool = m_toolObjList.first(); tool; tool = m_toolObjList.next() ) {
      if ( tool->name() == name )
         return tool;
   }
   vk_assert_never_reached();
   return NULL;
}