public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one
@ 2023-12-05 19:30 Alexandre Oliva
0 siblings, 0 replies; 10+ messages in thread
From: Alexandre Oliva @ 2023-12-05 19:30 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:e719222b493e070d8fa2da23e69e71099243def0
commit e719222b493e070d8fa2da23e69e71099243def0
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Dec 1 10:28:19 2023 -0300
untyped calls: use wrapper class type for implicit plus_one
Instead of get and set macros to apply a delta, use a single macro
that resorts to a temporary wrapper class to apply it.
To be combined (or not) with the previous patch.
Diff:
---
gcc/builtins.cc | 32 ++++++++++++++++++++------------
1 file changed, 20 insertions(+), 12 deletions(-)
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index d2884bd60af..3b75e074388 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -1403,16 +1403,24 @@ get_memory_rtx (tree exp, tree len)
\f
/* Built-in functions to perform an untyped call and return. */
-#define set_apply_args_size(x) \
- (this_target_builtins->x_apply_args_size_plus_one = 1 + (x))
-#define get_apply_args_size() \
- (this_target_builtins->x_apply_args_size_plus_one - 1)
+/* Wrapper that implicitly applies a delta when getting or setting the
+ enclosed value. */
+template <typename T>
+class delta_type
+{
+ T &value; T const delta;
+public:
+ delta_type (T &val, T dlt) : value (val), delta (dlt) {}
+ operator T () const { return value + delta; }
+ T operator = (T val) const { value = val - delta; return val; }
+};
+
+#define saved_apply_args_size \
+ (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
#define apply_args_mode \
(this_target_builtins->x_apply_args_mode)
-#define set_apply_result_size(x) \
- (this_target_builtins->x_apply_result_size_plus_one = 1 + (x))
-#define get_apply_result_size() \
- (this_target_builtins->x_apply_result_size_plus_one - 1)
+#define saved_apply_result_size \
+ (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
#define apply_result_mode \
(this_target_builtins->x_apply_result_mode)
@@ -1422,7 +1430,7 @@ get_memory_rtx (tree exp, tree len)
static int
apply_args_size (void)
{
- int size = get_apply_args_size ();
+ int size = saved_apply_args_size;
int align;
unsigned int regno;
@@ -1456,7 +1464,7 @@ apply_args_size (void)
else
apply_args_mode[regno] = as_a <fixed_size_mode> (VOIDmode);
- set_apply_args_size (size);
+ saved_apply_args_size = size;
}
return size;
}
@@ -1467,7 +1475,7 @@ apply_args_size (void)
static int
apply_result_size (void)
{
- int size = get_apply_result_size ();
+ int size = saved_apply_result_size;
int align, regno;
/* The values computed by this function never change. */
@@ -1500,7 +1508,7 @@ apply_result_size (void)
size = APPLY_RESULT_SIZE;
#endif
- set_apply_result_size (size);
+ saved_apply_result_size = size;
}
return size;
}
^ permalink raw reply [flat|nested] 10+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one
@ 2023-12-06 22:47 Alexandre Oliva
0 siblings, 0 replies; 10+ messages in thread
From: Alexandre Oliva @ 2023-12-06 22:47 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:c1142f32448d4622a5027dd254614701a2a619ba
commit c1142f32448d4622a5027dd254614701a2a619ba
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Dec 1 10:28:19 2023 -0300
untyped calls: use wrapper class type for implicit plus_one
Instead of get and set macros to apply a delta, use a single macro
that resorts to a temporary wrapper class to apply it.
To be combined (or not) with the previous patch.
Diff:
---
gcc/builtins.cc | 32 ++++++++++++++++++++------------
1 file changed, 20 insertions(+), 12 deletions(-)
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index d2884bd60af..3b75e074388 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -1403,16 +1403,24 @@ get_memory_rtx (tree exp, tree len)
\f
/* Built-in functions to perform an untyped call and return. */
-#define set_apply_args_size(x) \
- (this_target_builtins->x_apply_args_size_plus_one = 1 + (x))
-#define get_apply_args_size() \
- (this_target_builtins->x_apply_args_size_plus_one - 1)
+/* Wrapper that implicitly applies a delta when getting or setting the
+ enclosed value. */
+template <typename T>
+class delta_type
+{
+ T &value; T const delta;
+public:
+ delta_type (T &val, T dlt) : value (val), delta (dlt) {}
+ operator T () const { return value + delta; }
+ T operator = (T val) const { value = val - delta; return val; }
+};
+
+#define saved_apply_args_size \
+ (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
#define apply_args_mode \
(this_target_builtins->x_apply_args_mode)
-#define set_apply_result_size(x) \
- (this_target_builtins->x_apply_result_size_plus_one = 1 + (x))
-#define get_apply_result_size() \
- (this_target_builtins->x_apply_result_size_plus_one - 1)
+#define saved_apply_result_size \
+ (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
#define apply_result_mode \
(this_target_builtins->x_apply_result_mode)
@@ -1422,7 +1430,7 @@ get_memory_rtx (tree exp, tree len)
static int
apply_args_size (void)
{
- int size = get_apply_args_size ();
+ int size = saved_apply_args_size;
int align;
unsigned int regno;
@@ -1456,7 +1464,7 @@ apply_args_size (void)
else
apply_args_mode[regno] = as_a <fixed_size_mode> (VOIDmode);
- set_apply_args_size (size);
+ saved_apply_args_size = size;
}
return size;
}
@@ -1467,7 +1475,7 @@ apply_args_size (void)
static int
apply_result_size (void)
{
- int size = get_apply_result_size ();
+ int size = saved_apply_result_size;
int align, regno;
/* The values computed by this function never change. */
@@ -1500,7 +1508,7 @@ apply_result_size (void)
size = APPLY_RESULT_SIZE;
#endif
- set_apply_result_size (size);
+ saved_apply_result_size = size;
}
return size;
}
^ permalink raw reply [flat|nested] 10+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one
@ 2023-12-06 20:01 Alexandre Oliva
0 siblings, 0 replies; 10+ messages in thread
From: Alexandre Oliva @ 2023-12-06 20:01 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:f2ed8f2699b0de17ef66b11d2f14c0120702c6a9
commit f2ed8f2699b0de17ef66b11d2f14c0120702c6a9
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Dec 1 10:28:19 2023 -0300
untyped calls: use wrapper class type for implicit plus_one
Instead of get and set macros to apply a delta, use a single macro
that resorts to a temporary wrapper class to apply it.
To be combined (or not) with the previous patch.
Diff:
---
gcc/builtins.cc | 32 ++++++++++++++++++++------------
1 file changed, 20 insertions(+), 12 deletions(-)
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index d2884bd60af..3b75e074388 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -1403,16 +1403,24 @@ get_memory_rtx (tree exp, tree len)
\f
/* Built-in functions to perform an untyped call and return. */
-#define set_apply_args_size(x) \
- (this_target_builtins->x_apply_args_size_plus_one = 1 + (x))
-#define get_apply_args_size() \
- (this_target_builtins->x_apply_args_size_plus_one - 1)
+/* Wrapper that implicitly applies a delta when getting or setting the
+ enclosed value. */
+template <typename T>
+class delta_type
+{
+ T &value; T const delta;
+public:
+ delta_type (T &val, T dlt) : value (val), delta (dlt) {}
+ operator T () const { return value + delta; }
+ T operator = (T val) const { value = val - delta; return val; }
+};
+
+#define saved_apply_args_size \
+ (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
#define apply_args_mode \
(this_target_builtins->x_apply_args_mode)
-#define set_apply_result_size(x) \
- (this_target_builtins->x_apply_result_size_plus_one = 1 + (x))
-#define get_apply_result_size() \
- (this_target_builtins->x_apply_result_size_plus_one - 1)
+#define saved_apply_result_size \
+ (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
#define apply_result_mode \
(this_target_builtins->x_apply_result_mode)
@@ -1422,7 +1430,7 @@ get_memory_rtx (tree exp, tree len)
static int
apply_args_size (void)
{
- int size = get_apply_args_size ();
+ int size = saved_apply_args_size;
int align;
unsigned int regno;
@@ -1456,7 +1464,7 @@ apply_args_size (void)
else
apply_args_mode[regno] = as_a <fixed_size_mode> (VOIDmode);
- set_apply_args_size (size);
+ saved_apply_args_size = size;
}
return size;
}
@@ -1467,7 +1475,7 @@ apply_args_size (void)
static int
apply_result_size (void)
{
- int size = get_apply_result_size ();
+ int size = saved_apply_result_size;
int align, regno;
/* The values computed by this function never change. */
@@ -1500,7 +1508,7 @@ apply_result_size (void)
size = APPLY_RESULT_SIZE;
#endif
- set_apply_result_size (size);
+ saved_apply_result_size = size;
}
return size;
}
^ permalink raw reply [flat|nested] 10+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one
@ 2023-12-06 2:31 Alexandre Oliva
0 siblings, 0 replies; 10+ messages in thread
From: Alexandre Oliva @ 2023-12-06 2:31 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:1d592156e1dd8e5423323db584e8ddb5567dcdab
commit 1d592156e1dd8e5423323db584e8ddb5567dcdab
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Dec 1 10:28:19 2023 -0300
untyped calls: use wrapper class type for implicit plus_one
Instead of get and set macros to apply a delta, use a single macro
that resorts to a temporary wrapper class to apply it.
To be combined (or not) with the previous patch.
Diff:
---
gcc/builtins.cc | 32 ++++++++++++++++++++------------
1 file changed, 20 insertions(+), 12 deletions(-)
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index d2884bd60af..3b75e074388 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -1403,16 +1403,24 @@ get_memory_rtx (tree exp, tree len)
\f
/* Built-in functions to perform an untyped call and return. */
-#define set_apply_args_size(x) \
- (this_target_builtins->x_apply_args_size_plus_one = 1 + (x))
-#define get_apply_args_size() \
- (this_target_builtins->x_apply_args_size_plus_one - 1)
+/* Wrapper that implicitly applies a delta when getting or setting the
+ enclosed value. */
+template <typename T>
+class delta_type
+{
+ T &value; T const delta;
+public:
+ delta_type (T &val, T dlt) : value (val), delta (dlt) {}
+ operator T () const { return value + delta; }
+ T operator = (T val) const { value = val - delta; return val; }
+};
+
+#define saved_apply_args_size \
+ (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
#define apply_args_mode \
(this_target_builtins->x_apply_args_mode)
-#define set_apply_result_size(x) \
- (this_target_builtins->x_apply_result_size_plus_one = 1 + (x))
-#define get_apply_result_size() \
- (this_target_builtins->x_apply_result_size_plus_one - 1)
+#define saved_apply_result_size \
+ (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
#define apply_result_mode \
(this_target_builtins->x_apply_result_mode)
@@ -1422,7 +1430,7 @@ get_memory_rtx (tree exp, tree len)
static int
apply_args_size (void)
{
- int size = get_apply_args_size ();
+ int size = saved_apply_args_size;
int align;
unsigned int regno;
@@ -1456,7 +1464,7 @@ apply_args_size (void)
else
apply_args_mode[regno] = as_a <fixed_size_mode> (VOIDmode);
- set_apply_args_size (size);
+ saved_apply_args_size = size;
}
return size;
}
@@ -1467,7 +1475,7 @@ apply_args_size (void)
static int
apply_result_size (void)
{
- int size = get_apply_result_size ();
+ int size = saved_apply_result_size;
int align, regno;
/* The values computed by this function never change. */
@@ -1500,7 +1508,7 @@ apply_result_size (void)
size = APPLY_RESULT_SIZE;
#endif
- set_apply_result_size (size);
+ saved_apply_result_size = size;
}
return size;
}
^ permalink raw reply [flat|nested] 10+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one
@ 2023-12-05 21:51 Alexandre Oliva
0 siblings, 0 replies; 10+ messages in thread
From: Alexandre Oliva @ 2023-12-05 21:51 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:9600577f21d56c1d6f8b3e4c1dfaf85c5e9c3390
commit 9600577f21d56c1d6f8b3e4c1dfaf85c5e9c3390
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Dec 1 10:28:19 2023 -0300
untyped calls: use wrapper class type for implicit plus_one
Instead of get and set macros to apply a delta, use a single macro
that resorts to a temporary wrapper class to apply it.
To be combined (or not) with the previous patch.
Diff:
---
gcc/builtins.cc | 32 ++++++++++++++++++++------------
1 file changed, 20 insertions(+), 12 deletions(-)
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index d2884bd60af..3b75e074388 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -1403,16 +1403,24 @@ get_memory_rtx (tree exp, tree len)
\f
/* Built-in functions to perform an untyped call and return. */
-#define set_apply_args_size(x) \
- (this_target_builtins->x_apply_args_size_plus_one = 1 + (x))
-#define get_apply_args_size() \
- (this_target_builtins->x_apply_args_size_plus_one - 1)
+/* Wrapper that implicitly applies a delta when getting or setting the
+ enclosed value. */
+template <typename T>
+class delta_type
+{
+ T &value; T const delta;
+public:
+ delta_type (T &val, T dlt) : value (val), delta (dlt) {}
+ operator T () const { return value + delta; }
+ T operator = (T val) const { value = val - delta; return val; }
+};
+
+#define saved_apply_args_size \
+ (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
#define apply_args_mode \
(this_target_builtins->x_apply_args_mode)
-#define set_apply_result_size(x) \
- (this_target_builtins->x_apply_result_size_plus_one = 1 + (x))
-#define get_apply_result_size() \
- (this_target_builtins->x_apply_result_size_plus_one - 1)
+#define saved_apply_result_size \
+ (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
#define apply_result_mode \
(this_target_builtins->x_apply_result_mode)
@@ -1422,7 +1430,7 @@ get_memory_rtx (tree exp, tree len)
static int
apply_args_size (void)
{
- int size = get_apply_args_size ();
+ int size = saved_apply_args_size;
int align;
unsigned int regno;
@@ -1456,7 +1464,7 @@ apply_args_size (void)
else
apply_args_mode[regno] = as_a <fixed_size_mode> (VOIDmode);
- set_apply_args_size (size);
+ saved_apply_args_size = size;
}
return size;
}
@@ -1467,7 +1475,7 @@ apply_args_size (void)
static int
apply_result_size (void)
{
- int size = get_apply_result_size ();
+ int size = saved_apply_result_size;
int align, regno;
/* The values computed by this function never change. */
@@ -1500,7 +1508,7 @@ apply_result_size (void)
size = APPLY_RESULT_SIZE;
#endif
- set_apply_result_size (size);
+ saved_apply_result_size = size;
}
return size;
}
^ permalink raw reply [flat|nested] 10+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one
@ 2023-12-03 1:46 Alexandre Oliva
0 siblings, 0 replies; 10+ messages in thread
From: Alexandre Oliva @ 2023-12-03 1:46 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:4cdde750e6aeb88e2323f9ff2a754875a443fbb6
commit 4cdde750e6aeb88e2323f9ff2a754875a443fbb6
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Dec 1 10:28:19 2023 -0300
untyped calls: use wrapper class type for implicit plus_one
Instead of get and set macros to apply a delta, use a single macro
that resorts to a temporary wrapper class to apply it.
To be combined (or not) with the previous patch.
Diff:
---
gcc/builtins.cc | 32 ++++++++++++++++++++------------
1 file changed, 20 insertions(+), 12 deletions(-)
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index 1a105955db6..67989e133e4 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -1400,16 +1400,24 @@ get_memory_rtx (tree exp, tree len)
\f
/* Built-in functions to perform an untyped call and return. */
-#define set_apply_args_size(x) \
- (this_target_builtins->x_apply_args_size_plus_one = 1 + (x))
-#define get_apply_args_size() \
- (this_target_builtins->x_apply_args_size_plus_one - 1)
+/* Wrapper that implicitly applies a delta when getting or setting the
+ enclosed value. */
+template <typename T>
+class delta_type
+{
+ T &value; T const delta;
+public:
+ delta_type (T &val, T dlt) : value (val), delta (dlt) {}
+ operator T () const { return value + delta; }
+ T operator = (T val) const { value = val - delta; return val; }
+};
+
+#define saved_apply_args_size \
+ (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
#define apply_args_mode \
(this_target_builtins->x_apply_args_mode)
-#define set_apply_result_size(x) \
- (this_target_builtins->x_apply_result_size_plus_one = 1 + (x))
-#define get_apply_result_size() \
- (this_target_builtins->x_apply_result_size_plus_one - 1)
+#define saved_apply_result_size \
+ (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
#define apply_result_mode \
(this_target_builtins->x_apply_result_mode)
@@ -1419,7 +1427,7 @@ get_memory_rtx (tree exp, tree len)
static int
apply_args_size (void)
{
- int size = get_apply_args_size ();
+ int size = saved_apply_args_size;
int align;
unsigned int regno;
@@ -1453,7 +1461,7 @@ apply_args_size (void)
else
apply_args_mode[regno] = as_a <fixed_size_mode> (VOIDmode);
- set_apply_args_size (size);
+ saved_apply_args_size = size;
}
return size;
}
@@ -1464,7 +1472,7 @@ apply_args_size (void)
static int
apply_result_size (void)
{
- int size = get_apply_result_size ();
+ int size = saved_apply_result_size;
int align, regno;
/* The values computed by this function never change. */
@@ -1497,7 +1505,7 @@ apply_result_size (void)
size = APPLY_RESULT_SIZE;
#endif
- set_apply_result_size (size);
+ saved_apply_result_size = size;
}
return size;
}
^ permalink raw reply [flat|nested] 10+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one
@ 2023-12-02 17:48 Alexandre Oliva
0 siblings, 0 replies; 10+ messages in thread
From: Alexandre Oliva @ 2023-12-02 17:48 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:23fef254c896ea86dea911140a4cf7eb11b0bb6a
commit 23fef254c896ea86dea911140a4cf7eb11b0bb6a
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Dec 1 10:28:19 2023 -0300
untyped calls: use wrapper class type for implicit plus_one
Instead of get and set macros to apply a delta, use a single macro
that resorts to a temporary wrapper class to apply it.
To be combined (or not) with the previous patch.
Diff:
---
gcc/builtins.cc | 32 ++++++++++++++++++++------------
1 file changed, 20 insertions(+), 12 deletions(-)
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index 1a105955db6..67989e133e4 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -1400,16 +1400,24 @@ get_memory_rtx (tree exp, tree len)
\f
/* Built-in functions to perform an untyped call and return. */
-#define set_apply_args_size(x) \
- (this_target_builtins->x_apply_args_size_plus_one = 1 + (x))
-#define get_apply_args_size() \
- (this_target_builtins->x_apply_args_size_plus_one - 1)
+/* Wrapper that implicitly applies a delta when getting or setting the
+ enclosed value. */
+template <typename T>
+class delta_type
+{
+ T &value; T const delta;
+public:
+ delta_type (T &val, T dlt) : value (val), delta (dlt) {}
+ operator T () const { return value + delta; }
+ T operator = (T val) const { value = val - delta; return val; }
+};
+
+#define saved_apply_args_size \
+ (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
#define apply_args_mode \
(this_target_builtins->x_apply_args_mode)
-#define set_apply_result_size(x) \
- (this_target_builtins->x_apply_result_size_plus_one = 1 + (x))
-#define get_apply_result_size() \
- (this_target_builtins->x_apply_result_size_plus_one - 1)
+#define saved_apply_result_size \
+ (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
#define apply_result_mode \
(this_target_builtins->x_apply_result_mode)
@@ -1419,7 +1427,7 @@ get_memory_rtx (tree exp, tree len)
static int
apply_args_size (void)
{
- int size = get_apply_args_size ();
+ int size = saved_apply_args_size;
int align;
unsigned int regno;
@@ -1453,7 +1461,7 @@ apply_args_size (void)
else
apply_args_mode[regno] = as_a <fixed_size_mode> (VOIDmode);
- set_apply_args_size (size);
+ saved_apply_args_size = size;
}
return size;
}
@@ -1464,7 +1472,7 @@ apply_args_size (void)
static int
apply_result_size (void)
{
- int size = get_apply_result_size ();
+ int size = saved_apply_result_size;
int align, regno;
/* The values computed by this function never change. */
@@ -1497,7 +1505,7 @@ apply_result_size (void)
size = APPLY_RESULT_SIZE;
#endif
- set_apply_result_size (size);
+ saved_apply_result_size = size;
}
return size;
}
^ permalink raw reply [flat|nested] 10+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one
@ 2023-12-01 23:42 Alexandre Oliva
0 siblings, 0 replies; 10+ messages in thread
From: Alexandre Oliva @ 2023-12-01 23:42 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:ef8614603d526f7e053035b487c3a273bfcf4e7e
commit ef8614603d526f7e053035b487c3a273bfcf4e7e
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Dec 1 10:28:19 2023 -0300
untyped calls: use wrapper class type for implicit plus_one
Instead of get and set macros to apply a delta, use a single macro
that resorts to a temporary wrapper class to apply it.
To be combined (or not) with the previous patch.
Diff:
---
gcc/builtins.cc | 32 ++++++++++++++++++++------------
1 file changed, 20 insertions(+), 12 deletions(-)
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index 039bb5e997a..a60e0a70845 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -1398,16 +1398,24 @@ get_memory_rtx (tree exp, tree len)
\f
/* Built-in functions to perform an untyped call and return. */
-#define set_apply_args_size(x) \
- (this_target_builtins->x_apply_args_size_plus_one = 1 + (x))
-#define get_apply_args_size() \
- (this_target_builtins->x_apply_args_size_plus_one - 1)
+/* Wrapper that implicitly applies a delta when getting or setting the
+ enclosed value. */
+template <typename T>
+class delta_type
+{
+ T &value; T const delta;
+public:
+ delta_type (T &val, T dlt) : value (val), delta (dlt) {}
+ operator T () const { return value + delta; }
+ T operator = (T val) const { value = val - delta; return val; }
+};
+
+#define saved_apply_args_size \
+ (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
#define apply_args_mode \
(this_target_builtins->x_apply_args_mode)
-#define set_apply_result_size(x) \
- (this_target_builtins->x_apply_result_size_plus_one = 1 + (x))
-#define get_apply_result_size() \
- (this_target_builtins->x_apply_result_size_plus_one - 1)
+#define saved_apply_result_size \
+ (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
#define apply_result_mode \
(this_target_builtins->x_apply_result_mode)
@@ -1417,7 +1425,7 @@ get_memory_rtx (tree exp, tree len)
static int
apply_args_size (void)
{
- int size = get_apply_args_size ();
+ int size = saved_apply_args_size;
int align;
unsigned int regno;
@@ -1451,7 +1459,7 @@ apply_args_size (void)
else
apply_args_mode[regno] = as_a <fixed_size_mode> (VOIDmode);
- set_apply_args_size (size);
+ saved_apply_args_size = size;
}
return size;
}
@@ -1462,7 +1470,7 @@ apply_args_size (void)
static int
apply_result_size (void)
{
- int size = get_apply_result_size ();
+ int size = saved_apply_result_size;
int align, regno;
/* The values computed by this function never change. */
@@ -1495,7 +1503,7 @@ apply_result_size (void)
size = APPLY_RESULT_SIZE;
#endif
- set_apply_result_size (size);
+ saved_apply_result_size = size;
}
return size;
}
^ permalink raw reply [flat|nested] 10+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one
@ 2023-12-01 18:04 Alexandre Oliva
0 siblings, 0 replies; 10+ messages in thread
From: Alexandre Oliva @ 2023-12-01 18:04 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:03486b004e5fdf7c62c3bf5c20175b1334afedc0
commit 03486b004e5fdf7c62c3bf5c20175b1334afedc0
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Dec 1 10:28:19 2023 -0300
untyped calls: use wrapper class type for implicit plus_one
Instead of get and set macros to apply a delta, use a single macro
that resorts to a temporary wrapper class to apply it.
To be combined (or not) with the previous patch.
Diff:
---
gcc/builtins.cc | 32 ++++++++++++++++++++------------
1 file changed, 20 insertions(+), 12 deletions(-)
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index 039bb5e997a..a60e0a70845 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -1398,16 +1398,24 @@ get_memory_rtx (tree exp, tree len)
\f
/* Built-in functions to perform an untyped call and return. */
-#define set_apply_args_size(x) \
- (this_target_builtins->x_apply_args_size_plus_one = 1 + (x))
-#define get_apply_args_size() \
- (this_target_builtins->x_apply_args_size_plus_one - 1)
+/* Wrapper that implicitly applies a delta when getting or setting the
+ enclosed value. */
+template <typename T>
+class delta_type
+{
+ T &value; T const delta;
+public:
+ delta_type (T &val, T dlt) : value (val), delta (dlt) {}
+ operator T () const { return value + delta; }
+ T operator = (T val) const { value = val - delta; return val; }
+};
+
+#define saved_apply_args_size \
+ (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
#define apply_args_mode \
(this_target_builtins->x_apply_args_mode)
-#define set_apply_result_size(x) \
- (this_target_builtins->x_apply_result_size_plus_one = 1 + (x))
-#define get_apply_result_size() \
- (this_target_builtins->x_apply_result_size_plus_one - 1)
+#define saved_apply_result_size \
+ (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
#define apply_result_mode \
(this_target_builtins->x_apply_result_mode)
@@ -1417,7 +1425,7 @@ get_memory_rtx (tree exp, tree len)
static int
apply_args_size (void)
{
- int size = get_apply_args_size ();
+ int size = saved_apply_args_size;
int align;
unsigned int regno;
@@ -1451,7 +1459,7 @@ apply_args_size (void)
else
apply_args_mode[regno] = as_a <fixed_size_mode> (VOIDmode);
- set_apply_args_size (size);
+ saved_apply_args_size = size;
}
return size;
}
@@ -1462,7 +1470,7 @@ apply_args_size (void)
static int
apply_result_size (void)
{
- int size = get_apply_result_size ();
+ int size = saved_apply_result_size;
int align, regno;
/* The values computed by this function never change. */
@@ -1495,7 +1503,7 @@ apply_result_size (void)
size = APPLY_RESULT_SIZE;
#endif
- set_apply_result_size (size);
+ saved_apply_result_size = size;
}
return size;
}
^ permalink raw reply [flat|nested] 10+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one
@ 2023-12-01 13:35 Alexandre Oliva
0 siblings, 0 replies; 10+ messages in thread
From: Alexandre Oliva @ 2023-12-01 13:35 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:93548239fae6d8bcaca3b5f0df98153732b0fa02
commit 93548239fae6d8bcaca3b5f0df98153732b0fa02
Author: Alexandre Oliva <oliva@gnu.org>
Date: Fri Dec 1 10:28:19 2023 -0300
untyped calls: use wrapper class type for implicit plus_one
Diff:
---
gcc/builtins.cc | 32 ++++++++++++++++++++------------
1 file changed, 20 insertions(+), 12 deletions(-)
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index 039bb5e997a..a60e0a70845 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -1398,16 +1398,24 @@ get_memory_rtx (tree exp, tree len)
\f
/* Built-in functions to perform an untyped call and return. */
-#define set_apply_args_size(x) \
- (this_target_builtins->x_apply_args_size_plus_one = 1 + (x))
-#define get_apply_args_size() \
- (this_target_builtins->x_apply_args_size_plus_one - 1)
+/* Wrapper that implicitly applies a delta when getting or setting the
+ enclosed value. */
+template <typename T>
+class delta_type
+{
+ T &value; T const delta;
+public:
+ delta_type (T &val, T dlt) : value (val), delta (dlt) {}
+ operator T () const { return value + delta; }
+ T operator = (T val) const { value = val - delta; return val; }
+};
+
+#define saved_apply_args_size \
+ (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
#define apply_args_mode \
(this_target_builtins->x_apply_args_mode)
-#define set_apply_result_size(x) \
- (this_target_builtins->x_apply_result_size_plus_one = 1 + (x))
-#define get_apply_result_size() \
- (this_target_builtins->x_apply_result_size_plus_one - 1)
+#define saved_apply_result_size \
+ (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
#define apply_result_mode \
(this_target_builtins->x_apply_result_mode)
@@ -1417,7 +1425,7 @@ get_memory_rtx (tree exp, tree len)
static int
apply_args_size (void)
{
- int size = get_apply_args_size ();
+ int size = saved_apply_args_size;
int align;
unsigned int regno;
@@ -1451,7 +1459,7 @@ apply_args_size (void)
else
apply_args_mode[regno] = as_a <fixed_size_mode> (VOIDmode);
- set_apply_args_size (size);
+ saved_apply_args_size = size;
}
return size;
}
@@ -1462,7 +1470,7 @@ apply_args_size (void)
static int
apply_result_size (void)
{
- int size = get_apply_result_size ();
+ int size = saved_apply_result_size;
int align, regno;
/* The values computed by this function never change. */
@@ -1495,7 +1503,7 @@ apply_result_size (void)
size = APPLY_RESULT_SIZE;
#endif
- set_apply_result_size (size);
+ saved_apply_result_size = size;
}
return size;
}
^ permalink raw reply [flat|nested] 10+ messages in thread
end of thread, other threads:[~2023-12-06 22:47 UTC | newest]
Thread overview: 10+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-12-05 19:30 [gcc(refs/users/aoliva/heads/testme)] untyped calls: use wrapper class type for implicit plus_one Alexandre Oliva
-- strict thread matches above, loose matches on Subject: below --
2023-12-06 22:47 Alexandre Oliva
2023-12-06 20:01 Alexandre Oliva
2023-12-06 2:31 Alexandre Oliva
2023-12-05 21:51 Alexandre Oliva
2023-12-03 1:46 Alexandre Oliva
2023-12-02 17:48 Alexandre Oliva
2023-12-01 23:42 Alexandre Oliva
2023-12-01 18:04 Alexandre Oliva
2023-12-01 13:35 Alexandre Oliva
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).