Warning, /kdevelop/kdev-valgrind/tools/memcheck/memcheck_configpage.ui is written in an unsupported language. File is not indexed.

0001 <?xml version="1.0" encoding="UTF-8"?>
0002 <ui version="4.0">
0003  <class>Valgrind::MemcheckConfigPage</class>
0004  <widget class="QWidget" name="Valgrind::MemcheckConfigPage">
0005   <property name="geometry">
0006    <rect>
0007     <x>0</x>
0008     <y>0</y>
0009     <width>794</width>
0010     <height>732</height>
0011    </rect>
0012   </property>
0013   <layout class="QVBoxLayout" name="verticalLayout">
0014    <item>
0015     <widget class="QGroupBox" name="groupBox">
0016      <property name="title">
0017       <string/>
0018      </property>
0019      <layout class="QVBoxLayout" name="verticalLayout_2">
0020       <item>
0021        <layout class="QFormLayout" name="formLayout">
0022         <item row="0" column="0">
0023          <widget class="QLabel" name="leakResolutionLabel">
0024           <property name="text">
0025            <string>Leak resolution:</string>
0026           </property>
0027          </widget>
0028         </item>
0029         <item row="0" column="1">
0030          <widget class="Valgrind::ComboBox" name="kcfg_leakResolution">
0031           <property name="toolTip">
0032            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When doing leak checking, determines how willing Memcheck is to consider different backtraces to be the same for the purposes of merging multiple leaks into a single leak report. When set to &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;low&lt;/span&gt;, only the first two entries need match. When &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;med&lt;/span&gt;, four entries have to match. When &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;high&lt;/span&gt;, all entries need to match.&lt;/p&gt;&lt;p&gt;For hardcore leak debugging, you probably want to use &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--leak-resolution=high&lt;/span&gt; together with &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--num-callers=40&lt;/span&gt; or some such large number.&lt;/p&gt;&lt;p&gt;Note that the &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--leak-resolution&lt;/span&gt; setting does not affect Memcheck's ability to find leaks. It only changes how the results are presented.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
0033           </property>
0034          </widget>
0035         </item>
0036         <item row="1" column="0">
0037          <widget class="QLabel" name="showLeakKindsLabel">
0038           <property name="text">
0039            <string>Show leak kinds:</string>
0040           </property>
0041          </widget>
0042         </item>
0043         <item row="1" column="1">
0044          <widget class="MenuButton" name="kcfg_showLeakKinds">
0045           <property name="toolTip">
0046            <string>Specifies the leak kinds to show.</string>
0047           </property>
0048           <property name="text">
0049            <string notr="true"/>
0050           </property>
0051           <property name="flat">
0052            <bool>false</bool>
0053           </property>
0054          </widget>
0055         </item>
0056         <item row="2" column="0">
0057          <widget class="QLabel" name="leakCheckHeuristicsLabel">
0058           <property name="text">
0059            <string>Used heuristics:</string>
0060           </property>
0061          </widget>
0062         </item>
0063         <item row="2" column="1">
0064          <widget class="MenuButton" name="kcfg_leakCheckHeuristics">
0065           <property name="toolTip">
0066            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Specifies the set of leak check heuristics to be used during leak searches. The heuristics control which interior pointers to a block cause it to be considered as reachable.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
0067           </property>
0068           <property name="text">
0069            <string/>
0070           </property>
0071          </widget>
0072         </item>
0073         <item row="3" column="0">
0074          <widget class="QLabel" name="keepStacktracesLabel">
0075           <property name="text">
0076            <string>Stacktraces keeping:</string>
0077           </property>
0078          </widget>
0079         </item>
0080         <item row="3" column="1">
0081          <widget class="Valgrind::ComboBox" name="kcfg_keepStacktraces">
0082           <property name="toolTip">
0083            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Controls which stack trace(s) to keep for malloc'd and/or free'd blocks. &lt;/p&gt;&lt;p&gt;With &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;alloc-then-free&lt;/span&gt;, a stack trace is recorded at allocation time, and is associated with the block. When the block is freed, a second stack trace is recorded, and this replaces the allocation stack trace. As a result, any &amp;quot;use after free&amp;quot; errors relating to this block can only show a stack trace for where the block was freed. &lt;/p&gt;&lt;p&gt;With &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;alloc-and-free&lt;/span&gt;, both allocation and the deallocation stack traces for the block are stored. Hence a &amp;quot;use after free&amp;quot; error will show both, which may make the error easier to diagnose. Compared to &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;alloc-then-free&lt;/span&gt;, this setting slightly increases Valgrind's memory use as the block contains two references instead of one. &lt;/p&gt;&lt;p&gt;With &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;alloc&lt;/span&gt;, only the allocation stack trace is recorded (and reported). With &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;free&lt;/span&gt;, only the deallocation stack trace is recorded (and reported). These values somewhat decrease Valgrind's memory and cpu usage. They can be useful depending on the error types you are searching for and the level of detail you need to analyze them. For example, if you are only interested in memory leak errors, it is sufficient to record the allocation stack traces. &lt;/p&gt;&lt;p&gt;With &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;none&lt;/span&gt;, no stack traces are recorded for malloc and free operations. If your program allocates a lot of blocks and/or allocates/frees from many different stack traces, this can significantly decrease cpu and/or memory required. Of course, few details will be reported for errors related to heap blocks. &lt;/p&gt;&lt;p&gt;Note that once a stack trace is recorded, Valgrind keeps the stack trace in memory even if it is not referenced by any block. Some programs (for example, recursive algorithms) can generate a huge number of stack traces. If Valgrind uses too much memory in such circumstances, you can reduce the memory required with the options &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--keep-stacktraces&lt;/span&gt; and/or by using a smaller value for the option &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--num-callers&lt;/span&gt;. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
0084           </property>
0085          </widget>
0086         </item>
0087         <item row="4" column="0">
0088          <widget class="QLabel" name="freelistVolLabel">
0089           <property name="text">
0090            <string>Freelist maximum size:</string>
0091           </property>
0092           <property name="buddy">
0093            <cstring>kcfg_freelistVol</cstring>
0094           </property>
0095          </widget>
0096         </item>
0097         <item row="4" column="1">
0098          <widget class="QSpinBox" name="kcfg_freelistVol">
0099           <property name="toolTip">
0100            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When the client program releases memory using &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;free&lt;/span&gt; (in &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;C&lt;/span&gt;) or &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;delete&lt;/span&gt; (&lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;C++&lt;/span&gt;), that memory is not immediately made available for re-allocation. Instead, it is marked inaccessible and placed in a queue of freed blocks. The purpose is to defer as long as possible the point at which freed-up memory comes back into circulation. This increases the chance that Memcheck will be able to detect invalid accesses to blocks for some significant period of time after they have been freed.&lt;/p&gt;&lt;p&gt;This option specifies the maximum total size, in bytes, of the blocks in the queue. The default value is twenty million bytes. Increasing this increases the total amount of memory used by Memcheck but may detect invalid uses of freed blocks which would otherwise go undetected.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
0101           </property>
0102          </widget>
0103         </item>
0104         <item row="5" column="0">
0105          <widget class="QLabel" name="freelistBigBlocksLabel">
0106           <property name="text">
0107            <string>Freelist big-blocks:</string>
0108           </property>
0109          </widget>
0110         </item>
0111         <item row="5" column="1">
0112          <widget class="QSpinBox" name="kcfg_freelistBigBlocks">
0113           <property name="toolTip">
0114            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When making blocks from the queue of freed blocks available for re-allocation, Memcheck will in priority re-circulate the blocks with a size greater or equal to &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--freelist-big-blocks&lt;/span&gt;. This ensures that freeing big blocks (in particular freeing blocks bigger than &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--freelist-vol&lt;/span&gt;) does not immediately lead to a re-circulation of all (or a lot of) the small blocks in the free list. In other words, this option increases the likelihood to discover dangling pointers for the &amp;quot;small&amp;quot; blocks, even when big blocks are freed.&lt;/p&gt;&lt;p&gt;Setting a value of 0 means that all the blocks are re-circulated in a FIFO order.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
0115           </property>
0116          </widget>
0117         </item>
0118         <item row="6" column="0">
0119          <widget class="QLabel" name="extraArgsLabel">
0120           <property name="text">
0121            <string>E&amp;xtra parameters:</string>
0122           </property>
0123           <property name="buddy">
0124            <cstring>kcfg_extraArgs</cstring>
0125           </property>
0126          </widget>
0127         </item>
0128         <item row="6" column="1">
0129          <widget class="QLineEdit" name="kcfg_extraArgs">
0130           <property name="clearButtonEnabled">
0131            <bool>true</bool>
0132           </property>
0133          </widget>
0134         </item>
0135        </layout>
0136       </item>
0137       <item>
0138        <widget class="Line" name="line">
0139         <property name="orientation">
0140          <enum>Qt::Horizontal</enum>
0141         </property>
0142        </widget>
0143       </item>
0144       <item>
0145        <widget class="QCheckBox" name="kcfg_undefValueErrors">
0146         <property name="enabled">
0147          <bool>true</bool>
0148         </property>
0149         <property name="toolTip">
0150          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Controls whether Memcheck reports uses of undefined value errors. Set this to &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;no&lt;/span&gt; if you don't want to see undefined value errors. It also has the side effect of speeding up Memcheck somewhat.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
0151         </property>
0152         <property name="text">
0153          <string>Show undefined values usage</string>
0154         </property>
0155         <property name="checked">
0156          <bool>false</bool>
0157         </property>
0158        </widget>
0159       </item>
0160       <item>
0161        <widget class="QCheckBox" name="kcfg_showMismatchedFrees">
0162         <property name="toolTip">
0163          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When enabled, Memcheck checks that heap blocks are deallocated using a function that matches the allocating function. That is, it expects &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;free&lt;/span&gt; to be used to deallocate blocks allocated by &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;malloc&lt;/span&gt;, &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;delete&lt;/span&gt; for blocks allocated by &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;new&lt;/span&gt;, and &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;delete[]&lt;/span&gt; for blocks allocated by &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;new[]&lt;/span&gt;. If a mismatch is detected, an error is reported. This is in general important because in some environments, freeing with a non-matching function can cause crashes.&lt;/p&gt;&lt;p&gt;There is however a scenario where such mismatches cannot be avoided. That is when the user provides implementations of &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;new&lt;/span&gt;/&lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;new[]&lt;/span&gt; that call &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;malloc&lt;/span&gt; and of &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;delete&lt;/span&gt;/&lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;delete[]&lt;/span&gt; that call &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;free&lt;/span&gt;, and these functions are asymmetrically inlined. For example, imagine that &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;delete[]&lt;/span&gt; is inlined but &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;new[]&lt;/span&gt; is not. The result is that Memcheck &amp;quot;sees&amp;quot; all &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;delete[]&lt;/span&gt; calls as direct calls to &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;free&lt;/span&gt;, even when the program source contains no mismatched calls.&lt;/p&gt;&lt;p&gt;This causes a lot of confusing and irrelevant error reports. &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--show-mismatched-frees=no&lt;/span&gt; disables these checks. It is not generally advisable to disable them, though, because you may miss real errors as a result.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
0164         </property>
0165         <property name="text">
0166          <string>Show mismatched frees</string>
0167         </property>
0168        </widget>
0169       </item>
0170       <item>
0171        <widget class="QCheckBox" name="kcfg_partialLoadsOk">
0172         <property name="toolTip">
0173          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Controls how Memcheck handles 32-, 64-, 128- and 256-bit naturally aligned loads from addresses for which some bytes are addressable and others are not. When &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;yes&lt;/span&gt;, such loads do not produce an address error. Instead, loaded bytes originating from illegal addresses are marked as uninitialised, and those corresponding to legal addresses are handled in the normal way.&lt;/p&gt;&lt;p&gt;When &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;no&lt;/span&gt;, loads from partially invalid addresses are treated the same as loads from completely invalid addresses: an illegal-address error is issued, and the resulting bytes are marked as initialised.&lt;/p&gt;&lt;p&gt;Note that code that behaves in this way is in violation of the ISO C/C++ standards, and should be considered broken. If at all possible, such code should be fixed.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
0174         </property>
0175         <property name="text">
0176          <string>Allow partial loads</string>
0177         </property>
0178        </widget>
0179       </item>
0180       <item>
0181        <widget class="QCheckBox" name="kcfg_trackOrigins">
0182         <property name="toolTip">
0183          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Controls whether Memcheck tracks the origin of uninitialised values. By default, it does not, which means that although it can tell you that an uninitialised value is being used in a dangerous way, it cannot tell you where the uninitialised value came from. This often makes it difficult to track down the root problem.&lt;/p&gt;&lt;p&gt;When set to &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;yes&lt;/span&gt;, Memcheck keeps track of the origins of all uninitialised values. Then, when an uninitialised value error is reported, Memcheck will try to show the origin of the value. An origin can be one of the following four places: a heap block, a stack allocation, a client request, or miscellaneous other sources (eg, a call to &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;brk&lt;/span&gt;).&lt;/p&gt;&lt;p&gt;For uninitialised values originating from a heap block, Memcheck shows where the block was allocated. For uninitialised values originating from a stack allocation, Memcheck can tell you which function allocated the value, but no more than that -- typically it shows you the source location of the opening brace of the function. So you should carefully check that all of the function's local variables are initialised properly. &lt;/p&gt;&lt;p&gt;Performance overhead: origin tracking is expensive. It halves Memcheck's speed and increases memory use by a minimum of 100MB, and possibly more. Nevertheless it can drastically reduce the effort required to identify the root cause of uninitialised value errors, and so is often a programmer productivity win, despite running more slowly. &lt;/p&gt;&lt;p&gt;Accuracy: Memcheck tracks origins quite accurately. To avoid very large space and time overheads, some approximations are made. It is possible, although unlikely, that Memcheck will report an incorrect origin, or not be able to identify any origin. &lt;/p&gt;&lt;p&gt;Note that the combination &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--track-origins=yes&lt;/span&gt; and &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--undef-value-errors=no&lt;/span&gt; is nonsensical. Memcheck checks for and rejects this combination at startup.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
0184         </property>
0185         <property name="text">
0186          <string>Track origins of all uninitialised values</string>
0187         </property>
0188        </widget>
0189       </item>
0190       <item>
0191        <widget class="QCheckBox" name="kcfg_expensiveDefinednessChecks">
0192         <property name="toolTip">
0193          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Controls whether Memcheck should employ more precise but also more expensive (time consuming) algorithms when checking the definedness of a value. The default setting is not to do that and it is usually sufficient. However, for highly optimised code valgrind may sometimes incorrectly complain. Invoking valgrind with &lt;span style=&quot; font-family:'Monospace'; font-weight:600; font-style:italic;&quot;&gt;--expensive-definedness-checks=yes&lt;/span&gt; helps but comes at a performance cost. Runtime degradation of 25% have been observed but the extra cost depends a lot on the application at hand.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
0194         </property>
0195         <property name="text">
0196          <string>Expensive definedness checks</string>
0197         </property>
0198        </widget>
0199       </item>
0200       <item>
0201        <widget class="Line" name="line_2">
0202         <property name="orientation">
0203          <enum>Qt::Horizontal</enum>
0204         </property>
0205        </widget>
0206       </item>
0207       <item>
0208        <widget class="QCheckBox" name="kcfg_showInstructionPointer">
0209         <property name="text">
0210          <string>Show stack frame instruction pointer value</string>
0211         </property>
0212        </widget>
0213       </item>
0214      </layout>
0215     </widget>
0216    </item>
0217    <item>
0218     <spacer>
0219      <property name="orientation">
0220       <enum>Qt::Vertical</enum>
0221      </property>
0222      <property name="sizeHint" stdset="0">
0223       <size>
0224        <width>20</width>
0225        <height>71</height>
0226       </size>
0227      </property>
0228     </spacer>
0229    </item>
0230   </layout>
0231  </widget>
0232  <customwidgets>
0233   <customwidget>
0234    <class>MenuButton</class>
0235    <extends>QPushButton</extends>
0236    <header>core/widgets/menubutton.h</header>
0237   </customwidget>
0238   <customwidget>
0239    <class>Valgrind::ComboBox</class>
0240    <extends>QComboBox</extends>
0241    <header>core/widgets/combobox.h</header>
0242   </customwidget>
0243  </customwidgets>
0244  <tabstops>
0245   <tabstop>kcfg_leakResolution</tabstop>
0246   <tabstop>kcfg_showLeakKinds</tabstop>
0247   <tabstop>kcfg_leakCheckHeuristics</tabstop>
0248   <tabstop>kcfg_keepStacktraces</tabstop>
0249   <tabstop>kcfg_freelistVol</tabstop>
0250   <tabstop>kcfg_freelistBigBlocks</tabstop>
0251   <tabstop>kcfg_extraArgs</tabstop>
0252   <tabstop>kcfg_undefValueErrors</tabstop>
0253   <tabstop>kcfg_showMismatchedFrees</tabstop>
0254   <tabstop>kcfg_partialLoadsOk</tabstop>
0255   <tabstop>kcfg_trackOrigins</tabstop>
0256   <tabstop>kcfg_expensiveDefinednessChecks</tabstop>
0257   <tabstop>kcfg_showInstructionPointer</tabstop>
0258  </tabstops>
0259  <resources/>
0260  <connections/>
0261 </ui>