WWW-www.enlightenment.org pushed a commit to branch master.
http://git.enlightenment.org/website/www-content.git/commit/?id=06ec72372964661c8acae8883e27cf81abd20220
commit 06ec72372964661c8acae8883e27cf81abd20220
Author: Gareth Halfacree <freela...@halfacree.co.uk>
Date: Thu Nov 30 05:26:40 2017 -0800
Wiki page valgrind.md changed with summary [created] by Gareth Halfacree
---
pages/develop/debug/c/valgrind.md.txt | 102 ++++++++++++++++++++++++++++++++++
1 file changed, 102 insertions(+)
diff --git a/pages/develop/debug/c/valgrind.md.txt
b/pages/develop/debug/c/valgrind.md.txt
new file mode 100644
index 000000000..ac61f051b
--- /dev/null
+++ b/pages/develop/debug/c/valgrind.md.txt
@@ -0,0 +1,102 @@
+---
+~~Title: Debugging with Valgrind~~
+---
+
+# Debugging with Valgrind #
+
+Valgrind is a collection of tools for tracking down memory-related issues,
from memory leaks through to uninitialized variables. While more information on
Valgrind is available on the [Valgrind
website](http://valgrind.org/docs/manual/manual.html), this document introduces
its use specifically for debugging applications written with the Enlightenment
Foundation Libraries (EFL).
+
+## Debugging a Memory Leak ##
+
+In this example an ``Eina`` array is created in a callback function but it is
never freed. This generates a memory leak. Begin by creating the following
program:
+
+```c
+#include <Elementary.h>
+
+static void
+on_done(void *data, Evas_Object *obj, void *event_info)
+{
+ Eina_Array *array;
+ unsigned int i;
+
+ eina_init();
+ array = eina_array_new(100);
+ eina_array_step_set(array, sizeof(*array), 20);
+ for (i = 0; i < 20; i++) eina_array_push(array, strdup("hello"));
+
+ /****To free array****/
+ //while (eina_array_count(array))
+ //free(eina_array_pop(array));
+ //eina_array_free(array);
+
+ //eina_shutdown();
+
+ // quit the mainloop (elm_run function will return)
+ elm_exit();
+}
+
+EAPI_MAIN int
+elm_main(int argc, char **argv)
+{
+ Evas_Object *win, *box, *btn;
+
+ // new window
+ win = elm_win_util_standard_add("hello", "Hello");
+ // add a box object
+ box = elm_box_add(win);
+ // add object as a resize object for the window (controls window minimum
+ // size as well as gets resized if window is resized)
+ elm_win_resize_object_add(win, box);
+ evas_object_show(box);
+ // add a button
+ btn = elm_button_add(win);
+ // set default text of button to "SEG"
+ elm_object_text_set(btn, "SEG");
+ // pack the button at the end of the box
+ elm_box_pack_end(box, btn);
+ evas_object_show(btn);
+ // call on_done when button is clicked
+ evas_object_smart_callback_add(btn, "clicked", on_done, NULL);
+ //show the window
+ evas_object_show(win);
+
+ // run the mainloop and process events and callbacks
+ elm_run();
+ return 0;
+}
+ELM_MAIN()
+```
+
+Save the program as "hello.", compile it, and run it through Valgrind:
+
+```bash
+valgrind --leak-check=full --track-origins=yes ./hello
+[...]
+==22370== 312 (32 direct, 280 indirect) bytes in 1 blocks are definitely lost
+in loss record 349 of 417
+==22370== at 0x4C28C20: malloc (vg_replace_malloc.c:296)
+==22370== by 0x55A585D: eina_array_new (eina_array.c:279)
+==22370== by 0x400E4C: on_done (hello.c:7)
+==22370== by 0x5CD1B83: _eo_evas_smart_cb (evas_object_smart.c:65)
+==22370== by 0x6BCFD21: _eo_base_event_callback_call (eo_base_class.c:716)
+==22370== by 0x6BCEA96: eo_event_callback_call (in
+/usr/local/lib/libeo.so.1.14.99)
+==22370== by 0x5CD3BAC: evas_object_smart_callback_call
+(evas_object_smart.c:791)
+==22370== by 0x4F34B8B: _activate (elm_button.c:69)
+==22370== by 0x4F34BC1: _on_clicked_signal (elm_button.c:191)
+==22370== by 0x6970424: edje_match_callback_exec_check_finals
+(edje_match.c:556)
+==22370== by 0x6970424: edje_match_callback_exec (edje_match.c:712)
+==22370== by 0x697673C: _edje_emit_cb (edje_program.c:1392)
+==22370== by 0x697673C: _edje_emit_handle (edje_program.c:1345)
+==22370== by 0x6971295: _edje_message_process (edje_message_queue.c:651)
+[...]
+```
+
+All the memory accesses pass through Valgrind, so it shows you a backtrace
when an allocation is made and not freed.
+
+> **NOTE:**
+> There can be other traces in the ``HEAD SUMMARY``, but this example focuses
on the memory leak within the application. As a result you may have to ignore
things not relevant to that code.
+
+This backtrace demonstrates that an allocation took place in the
``eina_array_new()`` function. This function is called from the ``on_done()``
function. You can go further up the backtrace, but remember that a callback
function is called from ``Evas`` so there is a good chance that the allocation
is made in your specific callback function.
\ No newline at end of file
--
