From: Rico Tzschichholz Date: Mon, 15 Nov 2021 19:43:19 +0000 (+0100) Subject: codegen: Add and use CCodeConstantIdentifier for accessing constants X-Git-Tag: 0.55.1~73 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=5b6345a6386b05aaf3f11cb3572940413eb878a8;p=thirdparty%2Fvala.git codegen: Add and use CCodeConstantIdentifier for accessing constants If an address to a constant value is required then its identifier needs to be used instead of referring to a temporary copy. Fixes a regression of f1a8f2a4c6771124abd61fd0ebfa991c846575fe Found by -fsanitize=address --- diff --git a/ccode/Makefile.am b/ccode/Makefile.am index 9ba660760..c87c5dd1d 100644 --- a/ccode/Makefile.am +++ b/ccode/Makefile.am @@ -28,6 +28,7 @@ libvalaccode_la_VALASOURCES = \ valaccodecomment.vala \ valaccodeconditionalexpression.vala \ valaccodeconstant.vala \ + valaccodeconstantidentifier.vala \ valaccodecontinuestatement.vala \ valaccodedeclaration.vala \ valaccodedeclarator.vala \ diff --git a/ccode/valaccodeconstantidentifier.vala b/ccode/valaccodeconstantidentifier.vala new file mode 100644 index 000000000..0495389f1 --- /dev/null +++ b/ccode/valaccodeconstantidentifier.vala @@ -0,0 +1,35 @@ +/* valaccodeconstantidentifier.vala + * + * Copyright (C) 2021 Rico Tzschichholz + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: + * Rico Tzschichholz + */ + +using GLib; + +/** + * Represents a constant identifier in the C code. + */ +public class Vala.CCodeConstantIdentifier : CCodeIdentifier { + /** + * The name of this constant identifier. + */ + public CCodeConstantIdentifier (string name) { + base (name); + } +} diff --git a/codegen/valaccodebasemodule.vala b/codegen/valaccodebasemodule.vala index 409ebba6c..12bd99db2 100644 --- a/codegen/valaccodebasemodule.vala +++ b/codegen/valaccodebasemodule.vala @@ -1530,7 +1530,7 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator { } public static bool is_constant_ccode_expression (CCodeExpression cexpr) { - if (cexpr is CCodeConstant) { + if (cexpr is CCodeConstant || cexpr is CCodeConstantIdentifier) { return true; } else if (cexpr is CCodeCastExpression) { var ccast = (CCodeCastExpression) cexpr; @@ -6303,7 +6303,9 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator { result.value_type.nullable = false; if (!result.lvalue || !result.value_type.equals (value.value_type)) { result.cvalue = get_implicit_cast_expression (result.cvalue, value.value_type, result.value_type, node); - result = (GLibValue) store_temp_value (result, node); + if (!(result.cvalue is CCodeConstantIdentifier)) { + result = (GLibValue) store_temp_value (result, node); + } } result.cvalue = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, result.cvalue); result.lvalue = false; diff --git a/codegen/valaccodememberaccessmodule.vala b/codegen/valaccodememberaccessmodule.vala index 4a32ce899..0d5c8b4c3 100644 --- a/codegen/valaccodememberaccessmodule.vala +++ b/codegen/valaccodememberaccessmodule.vala @@ -158,8 +158,10 @@ public abstract class Vala.CCodeMemberAccessModule : CCodeControlFlowModule { s = current_method.get_full_name (); } set_cvalue (expr, new CCodeConstant ("\"%s\"".printf (s))); - } else { + } else if (c.type_reference.is_non_null_simple_type ()) { set_cvalue (expr, new CCodeConstant (get_ccode_name (c))); + } else { + set_cvalue (expr, new CCodeConstantIdentifier (get_ccode_name (c))); } if (array_type != null) { diff --git a/tests/Makefile.am b/tests/Makefile.am index ad65913ce..b7a40d46c 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -102,6 +102,7 @@ TESTS = \ basic-types/bug788775.vala \ constants/array-type-invalid.test \ constants/glog.vala \ + constants/member-access.vala \ constants/strings.vala \ namespace/unique.vala \ arrays/cast-silent-invalid.test \ diff --git a/tests/constants/member-access.c-expected b/tests/constants/member-access.c-expected new file mode 100644 index 000000000..bede8980a --- /dev/null +++ b/tests/constants/member-access.c-expected @@ -0,0 +1,370 @@ +/* constants_member_access.c generated by valac, the Vala compiler + * generated from constants_member_access.vala, do not modify */ + +#include +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define TYPE_FOO (foo_get_type ()) +typedef struct _Foo Foo; + +#define TYPE_BAR (bar_get_type ()) +#define BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BAR, Bar)) +#define BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BAR, BarClass)) +#define IS_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BAR)) +#define IS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BAR)) +#define BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BAR, BarClass)) + +typedef struct _Bar Bar; +typedef struct _BarClass BarClass; +typedef struct _BarPrivate BarPrivate; +typedef struct _ParamSpecBar ParamSpecBar; +#define _bar_unref0(var) ((var == NULL) ? NULL : (var = (bar_unref (var), NULL))) +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +struct _Foo { + gint i; +}; + +struct _Bar { + GTypeInstance parent_instance; + volatile int ref_count; + BarPrivate * priv; + Foo* foo; +}; + +struct _BarClass { + GTypeClass parent_class; + void (*finalize) (Bar *self); +}; + +struct _ParamSpecBar { + GParamSpec parent_instance; +}; + +static gpointer bar_parent_class = NULL; + +VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ; +VALA_EXTERN Foo* foo_dup (const Foo* self); +VALA_EXTERN void foo_free (Foo* self); +VALA_EXTERN gpointer bar_ref (gpointer instance); +VALA_EXTERN void bar_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_bar (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_bar (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_bar (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_bar (const GValue* value); +VALA_EXTERN GType bar_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Bar, bar_unref) +VALA_EXTERN Bar* bar_new (Foo* _foo); +VALA_EXTERN Bar* bar_construct (GType object_type, + Foo* _foo); +static void bar_finalize (Bar * obj); +static GType bar_get_type_once (void); +static void _vala_main (void); + +const Foo FOO = {23}; +const Foo FAZ = {42}; + +Foo* +foo_dup (const Foo* self) +{ + Foo* dup; + dup = g_new0 (Foo, 1); + memcpy (dup, self, sizeof (Foo)); + return dup; +} + +void +foo_free (Foo* self) +{ + g_free (self); +} + +static GType +foo_get_type_once (void) +{ + GType foo_type_id; + foo_type_id = g_boxed_type_register_static ("Foo", (GBoxedCopyFunc) foo_dup, (GBoxedFreeFunc) foo_free); + return foo_type_id; +} + +GType +foo_get_type (void) +{ + static volatile gsize foo_type_id__volatile = 0; + if (g_once_init_enter (&foo_type_id__volatile)) { + GType foo_type_id; + foo_type_id = foo_get_type_once (); + g_once_init_leave (&foo_type_id__volatile, foo_type_id); + } + return foo_type_id__volatile; +} + +Bar* +bar_construct (GType object_type, + Foo* _foo) +{ + Bar* self = NULL; + Foo _tmp0_; + g_return_val_if_fail (_foo != NULL, NULL); + self = (Bar*) g_type_create_instance (object_type); + _tmp0_ = *_foo; + self->foo = &_tmp0_; + return self; +} + +Bar* +bar_new (Foo* _foo) +{ + return bar_construct (TYPE_BAR, _foo); +} + +static void +value_bar_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_bar_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + bar_unref (value->data[0].v_pointer); + } +} + +static void +value_bar_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = bar_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_bar_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_bar_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Bar * object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = bar_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_bar_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Bar ** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = bar_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_bar (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecBar* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_BAR), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + +gpointer +value_get_bar (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BAR), NULL); + return value->data[0].v_pointer; +} + +void +value_set_bar (GValue* value, + gpointer v_object) +{ + Bar * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BAR)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BAR)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + bar_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + bar_unref (old); + } +} + +void +value_take_bar (GValue* value, + gpointer v_object) +{ + Bar * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BAR)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BAR)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + bar_unref (old); + } +} + +static void +bar_class_init (BarClass * klass, + gpointer klass_data) +{ + bar_parent_class = g_type_class_peek_parent (klass); + ((BarClass *) klass)->finalize = bar_finalize; +} + +static void +bar_instance_init (Bar * self, + gpointer klass) +{ + self->ref_count = 1; +} + +static void +bar_finalize (Bar * obj) +{ + Bar * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_BAR, Bar); + g_signal_handlers_destroy (self); +} + +static GType +bar_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_bar_init, value_bar_free_value, value_bar_copy_value, value_bar_peek_pointer, "p", value_bar_collect_value, "p", value_bar_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (BarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Bar), 0, (GInstanceInitFunc) bar_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType bar_type_id; + bar_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Bar", &g_define_type_info, &g_define_type_fundamental_info, 0); + return bar_type_id; +} + +GType +bar_get_type (void) +{ + static volatile gsize bar_type_id__volatile = 0; + if (g_once_init_enter (&bar_type_id__volatile)) { + GType bar_type_id; + bar_type_id = bar_get_type_once (); + g_once_init_leave (&bar_type_id__volatile, bar_type_id); + } + return bar_type_id__volatile; +} + +gpointer +bar_ref (gpointer instance) +{ + Bar * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +bar_unref (gpointer instance) +{ + Bar * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + BAR_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +static void +_vala_main (void) +{ + Bar* bar = NULL; + Foo* _tmp1_; + Foo* _tmp2_; + { + Bar* _tmp0_; + _tmp0_ = bar_new (&FOO); + _bar_unref0 (bar); + bar = _tmp0_; + } + _tmp1_ = bar->foo; + _vala_assert ((*_tmp1_).i == 23, "bar.foo.i == 23"); + { + bar->foo = &FAZ; + } + _tmp2_ = bar->foo; + _vala_assert ((*_tmp2_).i == 42, "bar.foo.i == 42"); + _bar_unref0 (bar); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + diff --git a/tests/constants/member-access.vala b/tests/constants/member-access.vala new file mode 100644 index 000000000..077a36474 --- /dev/null +++ b/tests/constants/member-access.vala @@ -0,0 +1,26 @@ +struct Foo { + public int i; +} + +const Foo FOO = { 23 }; +const Foo FAZ = { 42 }; + +class Bar { + public unowned Foo? foo; + + public Bar (Foo _foo) { + foo = _foo; + } +} + +void main () { + Bar bar; + { + bar = new Bar (FOO); + } + assert (bar.foo.i == 23); + { + bar.foo = FAZ; + } + assert (bar.foo.i == 42); +}