[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-trivial] [PATCH 01/88] cocci: script to use g_new() & friends
From: |
Philippe Mathieu-Daudé |
Subject: |
[Qemu-trivial] [PATCH 01/88] cocci: script to use g_new() & friends |
Date: |
Fri, 6 Oct 2017 20:48:56 -0300 |
Imported from Markus Armbruster commit b45c03f
Signed-off-by: Philippe Mathieu-Daudé <address@hidden>
---
Signed-off-by: Markus Armbruster <address@hidden>?
scripts/coccinelle/g_new.cocci | 101 +++++++++++++++++++++++++++++++++++++++++
1 file changed, 101 insertions(+)
create mode 100644 scripts/coccinelle/g_new.cocci
diff --git a/scripts/coccinelle/g_new.cocci b/scripts/coccinelle/g_new.cocci
new file mode 100644
index 0000000000..1e57685a6b
--- /dev/null
+++ b/scripts/coccinelle/g_new.cocci
@@ -0,0 +1,101 @@
+/* transform g_new*() alloc with size arguments of the form sizeof(T) [* N]
+ *
+ * g_new(T, n) is neater than g_malloc(sizeof(T) * n). It's also safer,
+ * for two reasons. One, it catches multiplication overflowing size_t.
+ * two, it returns T * rather than void *, which lets the compiler catch
+ * more type errors.
+ *
+ * Copyright: (C) 2017 Markus Armbruster <address@hidden>. GPLv2+.
+ * (Imported from b45c03f585ea9bb1af76c73e82195418c294919d)
+ *
+ * See http://lists.nongnu.org/archive/html/qemu-devel/2017-09/msg00908.html:
+ *
+ * g_new() advantages (from glib doc):
+ * - the returned pointer is cast to a pointer to the given type.
+ * - care is taken to avoid overflow when calculating the size of the
+ * allocated block.
+ *
+ * p = g_malloc(sizeof(*p)) is idiomatic, and not obviously inferior to
+ * p = g_new(T, 1), where T is the type of *p.
+ * But once you add multiplication, g_new() adds something useful: overflow
+ * protection. Conversion to g_new() might make sense then.
+ */
+
+@@
+type T;
+@@
+-g_malloc(sizeof(T))
++g_new(T, 1)
+@@
+type T;
+@@
+-g_try_malloc(sizeof(T))
++g_try_new(T, 1)
+@@
+type T;
+@@
+-g_malloc0(sizeof(T))
++g_new0(T, 1)
+@@
+type T;
+@@
+-g_try_malloc0(sizeof(T))
++g_try_new0(T, 1)
+
+@@
+type T;
+expression n;
+@@
+-g_malloc(sizeof(T) * (n))
++g_new(T, n)
+@@
+type T;
+expression n;
+@@
+-g_try_malloc(sizeof(T) * (n))
++g_try_new(T, n)
+@@
+type T;
+expression n;
+@@
+-g_malloc0(sizeof(T) * (n))
++g_new0(T, n)
+@@
+type T;
+expression n;
+@@
+-g_try_malloc0(sizeof(T) * (n))
++g_try_new0(T, n)
+
+@@
+type T;
+expression p, n;
+@@
+-g_realloc(p, sizeof(T) * (n))
++g_renew(T, p, n)
+@@
+type T;
+expression p, n;
+@@
+-g_try_realloc(p, sizeof(T) * (n))
++g_try_renew(T, p, n)
+
+// drop superfluous cast
+@@
+type T;
+expression n;
+@@
+-(T *)g_new(T, n)
++g_new(T, n)
+@@
+type T;
+expression n;
+@@
+-(T *)g_new0(T, n)
++g_new0(T, n)
+@@
+type T;
+expression p, n;
+@@
+-(T *)g_renew(T, p, n)
++g_renew(T, p, n)
--
2.14.2
- [Qemu-trivial] [PATCH 00/88] use g_new() family of functions, Philippe Mathieu-Daudé, 2017/10/06
- [Qemu-trivial] [PATCH 01/88] cocci: script to use g_new() & friends,
Philippe Mathieu-Daudé <=
- [Qemu-trivial] [PATCH 02/88] cocci: add more g_new() transformations, Philippe Mathieu-Daudé, 2017/10/06
- [Qemu-trivial] [PATCH 03/88] cocci: extract typeof() from g_new(), Philippe Mathieu-Daudé, 2017/10/06
- [Qemu-trivial] [PATCH 04/88] cocci: avoid use of g_new0(), Philippe Mathieu-Daudé, 2017/10/06
- [Qemu-trivial] [PATCH 05/88] cocci: use g_strfreev(), Philippe Mathieu-Daudé, 2017/10/06
- [Qemu-trivial] [PATCH 07/88] Audio: use g_new() family of functions, Philippe Mathieu-Daudé, 2017/10/06
- [Qemu-trivial] [PATCH 06/88] ARM: use g_new() family of functions, Philippe Mathieu-Daudé, 2017/10/06
- [Qemu-trivial] [PATCH 08/88] BT: use g_new() family of functions, Philippe Mathieu-Daudé, 2017/10/06