[PATCH 0/9] arch specific predefines

[PATCH 0/9] arch specific predefines

[Luc Van Oostenryck]

This series contains some small adjustments to the builtin types
and their predefined macros, for all supported architectures.

This should fully cover now all the integer types. The next step
would be the ones for floating-point numbers but it's not exactly
on the high-priority list.


Luc Van Oostenryck (9):
  sparc: add 'sparcv8' predefines for sparc32
  alpha: has 64-bit long double & int128
  ppc: add predefines __LONGDOUBLE128 & __LONG_DOUBLE_128__
  arch: add predefines __INT_LEAST${N}_TYPE__
  arch: add predefines __INT_FAST${N}_TYPE__
  predefine: teach sparse about __SIG_ATOMIC_TYPE__
  arch: allow target specific [u]intptr_t & ptrdiff_t
  x86-x32: fix it by defining a separate target for it
  predefine: let predefine_width() take the usual interface

 predefine.c         | 31 +++++++++++++++++++-----
 symbol.c            |  7 ++++++
 symbol.h            |  3 ---
 target-alpha.c      |  3 +++
 target-arm.c        |  7 ++++++
 target-h8300.c      |  7 ++++++
 target-m68k.c       |  9 +++++++
 target-microblaze.c |  9 +++++++
 target-nds32.c      |  5 ++++
 target-nios2.c      |  9 +++++++
 target-openrisc.c   |  5 ++++
 target-ppc.c        | 13 ++++++++++
 target-riscv.c      | 12 ++++++++-
 target-s390.c       | 12 +++++++++
 target-sh.c         |  8 ++++++
 target-sparc.c      | 24 +++++++++++++++---
 target-x86.c        | 59 +++++++++++++++++++++++++++++++++++++++++++++
 target-xtensa.c     |  5 ++++
 target.c            | 33 ++++++++++++++++++++++---
 target.h            | 21 ++++++++++++++++
 20 files changed, 266 insertions(+), 16 deletions(-)


base-commit: d2947a933574da18bab1ef7b7534199f44cf9e98
-- 
2.27.0

[PATCH 1/9] sparc: add 'sparcv8' predefines for sparc32

[Luc Van Oostenryck]

By default, the architecture version is 'v8' for sparc32
and 'v9' for sparc64.
The predefines were added for sparc64 but not for sparc32.

Fix this by adding a generic 'sparcv%d' together with a
variable to hold the architecture version and initialize
this one accordingly.

Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
 target-sparc.c | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/target-sparc.c b/target-sparc.c
index 865dbc8a2180..be4e968ec604 100644
--- a/target-sparc.c
+++ b/target-sparc.c
@@ -3,16 +3,25 @@
 #include "machine.h"
 
 
+static int sparc_version;
+
 static void predefine_sparc(const struct target *self)
 {
 	predefine("__sparc__", 1, "1");
 	predefine("__sparc", 1, "1");
 	predefine_nostd("sparc");
+
+	predefine_weak("__sparc_v%d__", sparc_version);
+	predefine_weak("__sparcv%d__", sparc_version);
+	predefine_weak("__sparcv%d", sparc_version);
 }
 
 
 static void init_sparc32(const struct target *target)
 {
+	if (!sparc_version)
+		sparc_version = 8;
+
 	if (arch_os == OS_SUNOS) {
 		wint_ctype = &long_ctype;
 		wchar_ctype = &long_ctype;
@@ -45,11 +54,14 @@ const struct target target_sparc32 = {
 };
 
 
+static void init_sparc64(const struct target *target)
+{
+	if (!sparc_version)
+		sparc_version = 9;
+}
+
 static void predefine_sparc64(const struct target *self)
 {
-	predefine("__sparc_v9__", 1, "1");
-	predefine("__sparcv9__", 1, "1");
-	predefine("__sparcv9", 1, "1");
 	predefine("__sparc64__", 1, "1");
 	predefine("__arch64__", 1, "1");
 
@@ -65,5 +77,6 @@ const struct target target_sparc64 = {
 
 	.target_32bit = &target_sparc32,
 
+	.init = init_sparc64,
 	.predefine = predefine_sparc64,
 };
-- 
2.27.0

[PATCH 2/9] alpha: has 64-bit long double & int128

[Luc Van Oostenryck]

Support for alpha was added in order to move the specific builtins
away from the common list without changing the defaults.

Improve the support for this arch by fixing a few specificities:
* support of 128-bit integers
* long doubles are 64-bit.

Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
 target-alpha.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/target-alpha.c b/target-alpha.c
index 3f582997eb96..4c622aec194f 100644
--- a/target-alpha.c
+++ b/target-alpha.c
@@ -24,6 +24,9 @@ static const struct builtin_fn builtins_alpha[] = {
 const struct target target_alpha = {
 	.mach = MACH_ALPHA,
 	.bitness = ARCH_LP64,
+	.has_int128 = 1,
+
+	.bits_in_longdouble = 64,
 
 	.predefine = predefine_alpha,
 	.builtins = builtins_alpha,
-- 
2.27.0

[PATCH 3/9] ppc: add predefines __LONGDOUBLE128 & __LONG_DOUBLE_128__

[Luc Van Oostenryck]

On powerpc, if long double is 128-bit width, then
'__LONGDOUBLE128' & '__LONG_DOUBLE_128__' should be defined.

So do this in the target specific file.

Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
 target-ppc.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/target-ppc.c b/target-ppc.c
index c0d6068f436a..dede8917cbd6 100644
--- a/target-ppc.c
+++ b/target-ppc.c
@@ -14,6 +14,10 @@ static void predefine_ppc(const struct target *self)
 	predefine("_ARCH_PPC", 1, "1");
 	if (arch_big_endian)
 		predefine("_BIG_ENDIAN", 1, "1");
+	if (ldouble_ctype.bit_size == 128) {
+		predefine("__LONGDOUBLE128", 1, "1");
+		predefine("__LONG_DOUBLE_128__", 1, "1");
+	}
 }
 
 static const char *asm_constraint_ppc(struct asm_operand *op, int c, const char *str)
-- 
2.27.0

[PATCH 4/9] arch: add predefines __INT_LEAST${N}_TYPE__

[Luc Van Oostenryck]

These are used by some system headers (neon on arm64).

Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
 predefine.c  | 9 +++++++++
 target-x86.c | 2 ++
 target.c     | 8 ++++++++
 target.h     | 8 ++++++++
 4 files changed, 27 insertions(+)

diff --git a/predefine.c b/predefine.c
index 94952e81d1df..062e754bf20f 100644
--- a/predefine.c
+++ b/predefine.c
@@ -145,6 +145,15 @@ void predefined_macros(void)
 	predefined_ctype("INT64",      int64_ctype, PTYPE_MAX|PTYPE_TYPE);
 	predefined_ctype("UINT64",    uint64_ctype, PTYPE_MAX|PTYPE_TYPE);
 
+	predefined_ctype("INT_LEAST8",   &schar_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
+	predefined_ctype("UINT_LEAST8",  &uchar_ctype, PTYPE_MAX|PTYPE_TYPE);
+	predefined_ctype("INT_LEAST16",  &short_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
+	predefined_ctype("UINT_LEAST16",&ushort_ctype, PTYPE_MAX|PTYPE_TYPE);
+	predefined_ctype("INT_LEAST32",   int32_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
+	predefined_ctype("UINT_LEAST32", uint32_ctype, PTYPE_MAX|PTYPE_TYPE);
+	predefined_ctype("INT_LEAST64",   int64_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
+	predefined_ctype("UINT_LEAST64", uint64_ctype, PTYPE_MAX|PTYPE_TYPE);
+
 	predefined_ctype("INTMAX",    intmax_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
 	predefined_ctype("UINTMAX",  uintmax_ctype, PTYPE_MAX|PTYPE_TYPE);
 	predefined_ctype("INTPTR",   ssize_t_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
diff --git a/target-x86.c b/target-x86.c
index 62323aecc52b..956af92efe4e 100644
--- a/target-x86.c
+++ b/target-x86.c
@@ -82,6 +82,8 @@ static void init_x86_64(const struct target *target)
 		uint64_ctype = &ullong_ctype;
 		intmax_ctype = &llong_ctype;
 		uintmax_ctype = &ullong_ctype;
+		least64_ctype = &long_ctype;
+		uleast64_ctype = &ulong_ctype;
 		break;
 	}
 }
diff --git a/target.c b/target.c
index cbb25724ae09..e2eb78e25328 100644
--- a/target.c
+++ b/target.c
@@ -15,6 +15,14 @@ struct symbol *int32_ctype = &int_ctype;
 struct symbol *uint32_ctype = &uint_ctype;
 struct symbol *wchar_ctype = &int_ctype;
 struct symbol *wint_ctype = &uint_ctype;
+struct symbol *least8_ctype = &schar_ctype;
+struct symbol *uleast8_ctype = &uchar_ctype;
+struct symbol *least16_ctype = &short_ctype;
+struct symbol *uleast16_ctype = &ushort_ctype;
+struct symbol *least32_ctype = &int_ctype;
+struct symbol *uleast32_ctype = &uint_ctype;
+struct symbol *least64_ctype = &llong_ctype;
+struct symbol *uleast64_ctype = &ullong_ctype;
 
 /*
  * For "__attribute__((aligned))"
diff --git a/target.h b/target.h
index fdf311297237..4140b77c4beb 100644
--- a/target.h
+++ b/target.h
@@ -13,6 +13,14 @@ extern struct symbol *int32_ctype;
 extern struct symbol *uint32_ctype;
 extern struct symbol *wchar_ctype;
 extern struct symbol *wint_ctype;
+extern struct symbol *least8_ctype;
+extern struct symbol *uleast8_ctype;
+extern struct symbol *least16_ctype;
+extern struct symbol *uleast16_ctype;
+extern struct symbol *least32_ctype;
+extern struct symbol *uleast32_ctype;
+extern struct symbol *least64_ctype;
+extern struct symbol *uleast64_ctype;
 
 /*
  * For "__attribute__((aligned))"
-- 
2.27.0

[PATCH 5/9] arch: add predefines __INT_FAST${N}_TYPE__

[Luc Van Oostenryck]

We just added __INT_LEAST${N}_TYPE__, so add these ones
too as they looks slightly more useful.

Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
 predefine.c         |  9 +++++++++
 target-arm.c        |  7 +++++++
 target-h8300.c      |  5 +++++
 target-m68k.c       |  9 +++++++++
 target-microblaze.c |  9 +++++++++
 target-nds32.c      |  5 +++++
 target-nios2.c      |  9 +++++++++
 target-openrisc.c   |  5 +++++
 target-ppc.c        |  9 +++++++++
 target-riscv.c      | 12 +++++++++++-
 target-s390.c       |  9 +++++++++
 target-sh.c         |  6 ++++++
 target-sparc.c      |  5 +++++
 target-x86.c        | 25 +++++++++++++++++++++++++
 target-xtensa.c     |  5 +++++
 target.c            | 10 ++++++++++
 target.h            |  8 ++++++++
 17 files changed, 146 insertions(+), 1 deletion(-)

diff --git a/predefine.c b/predefine.c
index 062e754bf20f..2e9913d5c0bc 100644
--- a/predefine.c
+++ b/predefine.c
@@ -154,6 +154,15 @@ void predefined_macros(void)
 	predefined_ctype("INT_LEAST64",   int64_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
 	predefined_ctype("UINT_LEAST64", uint64_ctype, PTYPE_MAX|PTYPE_TYPE);
 
+	predefined_ctype("INT_FAST8",    fast8_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
+	predefined_ctype("UINT_FAST8",  ufast8_ctype, PTYPE_MAX|PTYPE_TYPE);
+	predefined_ctype("INT_FAST16",  fast16_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
+	predefined_ctype("UINT_FAST16",ufast16_ctype, PTYPE_MAX|PTYPE_TYPE);
+	predefined_ctype("INT_FAST32",  fast32_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
+	predefined_ctype("UINT_FAST32",ufast32_ctype, PTYPE_MAX|PTYPE_TYPE);
+	predefined_ctype("INT_FAST64",  fast64_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
+	predefined_ctype("UINT_FAST64",ufast64_ctype, PTYPE_MAX|PTYPE_TYPE);
+
 	predefined_ctype("INTMAX",    intmax_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
 	predefined_ctype("UINTMAX",  uintmax_ctype, PTYPE_MAX|PTYPE_TYPE);
 	predefined_ctype("INTPTR",   ssize_t_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
diff --git a/target-arm.c b/target-arm.c
index 5fc15c511e1a..104c319b23dd 100644
--- a/target-arm.c
+++ b/target-arm.c
@@ -5,9 +5,16 @@
 
 static void init_arm(const struct target *self)
 {
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+
 	if (arch_os == OS_NONE) {
 		int32_ctype = &long_ctype;
 		uint32_ctype = &ulong_ctype;
+		fast8_ctype = &int_ctype;
+		ufast8_ctype = &uint_ctype;
 	}
 }
 
diff --git a/target-h8300.c b/target-h8300.c
index 47872b38a1ad..84d168b7410a 100644
--- a/target-h8300.c
+++ b/target-h8300.c
@@ -8,6 +8,11 @@ static void init_h8300(const struct target *self)
 	ssize_t_ctype = &long_ctype;
 	size_t_ctype = &ulong_ctype;
 	wchar_ctype = &ushort_ctype;
+
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
 }
 
 static void predefine_h8300(const struct target *self)
diff --git a/target-m68k.c b/target-m68k.c
index ed4a92733efe..0aed2eb362eb 100644
--- a/target-m68k.c
+++ b/target-m68k.c
@@ -3,6 +3,14 @@
 #include "machine.h"
 
 
+static void init_m68k(const struct target *self)
+{
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+}
+
 static void predefine_m68k(const struct target *self)
 {
 	predefine("__m68k__", 1, "1");
@@ -19,5 +27,6 @@ const struct target target_m68k = {
 	.bits_in_longdouble = 96,
 	.max_fp_alignment = 4,
 
+	.init = init_m68k,
 	.predefine = predefine_m68k,
 };
diff --git a/target-microblaze.c b/target-microblaze.c
index 1fbeef3c168d..3a4c3d58d77f 100644
--- a/target-microblaze.c
+++ b/target-microblaze.c
@@ -3,6 +3,14 @@
 #include "machine.h"
 
 
+static void init_microblaze(const struct target *self)
+{
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+}
+
 static void predefine_microblaze(const struct target *self)
 {
 	predefine("__MICROBLAZE__", 1, "1");
@@ -21,5 +29,6 @@ const struct target target_microblaze = {
 
 	.bits_in_longdouble = 64,
 
+	.init = init_microblaze,
 	.predefine = predefine_microblaze,
 };
diff --git a/target-nds32.c b/target-nds32.c
index 0dc483b26396..e3ed2e520883 100644
--- a/target-nds32.c
+++ b/target-nds32.c
@@ -5,6 +5,11 @@
 
 static void init_nds32(const struct target *self)
 {
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+
 	wchar_ctype = &uint_ctype;
 }
 
diff --git a/target-nios2.c b/target-nios2.c
index a478fff51e18..c57b171984a4 100644
--- a/target-nios2.c
+++ b/target-nios2.c
@@ -4,6 +4,14 @@
 #include "builtin.h"
 
 
+static void init_nios2(const struct target *self)
+{
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+}
+
 static void predefine_nios2(const struct target *self)
 {
 	predefine("__NIOS2", 1, "1");
@@ -33,6 +41,7 @@ const struct target target_nios2 = {
 
 	.bits_in_longdouble = 64,
 
+	.init = init_nios2,
 	.predefine = predefine_nios2,
 	.builtins = builtins_nios2,
 };
diff --git a/target-openrisc.c b/target-openrisc.c
index 553963c069ae..ad25ff2791d3 100644
--- a/target-openrisc.c
+++ b/target-openrisc.c
@@ -5,6 +5,11 @@
 
 static void init_openrisc(const struct target *self)
 {
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+
 	wchar_ctype = &uint_ctype;
 }
 
diff --git a/target-ppc.c b/target-ppc.c
index dede8917cbd6..6c0c0737482c 100644
--- a/target-ppc.c
+++ b/target-ppc.c
@@ -31,6 +31,14 @@ static const char *asm_constraint_ppc(struct asm_operand *op, int c, const char
 }
 
 
+static void init_ppc32(const struct target *self)
+{
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+}
+
 static void predefine_ppc32(const struct target *self)
 {
 	predefine_ppc(self);
@@ -46,6 +54,7 @@ const struct target target_ppc32 = {
 
 	.target_64bit = &target_ppc64,
 
+	.init = init_ppc32,
 	.predefine = predefine_ppc32,
 	.asm_constraint = asm_constraint_ppc,
 };
diff --git a/target-riscv.c b/target-riscv.c
index e7f2b03b821b..6d9113c125ee 100644
--- a/target-riscv.c
+++ b/target-riscv.c
@@ -87,6 +87,16 @@ static void init_riscv(const struct target *self)
 		riscv_flags = self->flags;
 }
 
+static void init_riscv32(const struct target *self)
+{
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+
+	init_riscv(self);
+}
+
 static void predefine_riscv(const struct target *self)
 {
 	static const char *cmodels[CMODEL_LAST] = {
@@ -131,7 +141,7 @@ const struct target target_riscv32 = {
 
 	.target_64bit = &target_riscv64,
 
-	.init = init_riscv,
+	.init = init_riscv32,
 	.predefine = predefine_riscv,
 	.parse_march = parse_march_riscv,
 };
diff --git a/target-s390.c b/target-s390.c
index 9dbc810e507c..cdbd685a2099 100644
--- a/target-s390.c
+++ b/target-s390.c
@@ -4,6 +4,14 @@
 #include "expression.h"
 
 
+static void init_s390(const struct target *self)
+{
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+}
+
 static void predefine_s390(const struct target *self)
 {
 	predefine("__s390__", 1, "1");
@@ -31,6 +39,7 @@ const struct target target_s390 = {
 
 	.target_64bit = &target_s390x,
 
+	.init = init_s390,
 	.predefine = predefine_s390,
 	.asm_constraint = asm_constraint_s390,
 };
diff --git a/target-sh.c b/target-sh.c
index db517ccb0f5c..d4ddf45504cf 100644
--- a/target-sh.c
+++ b/target-sh.c
@@ -7,6 +7,12 @@ static void init_sh(const struct target *self)
 {
 	int64_ctype = &llong_ctype;
 	uint64_ctype = &ullong_ctype;
+
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+
 	wchar_ctype = &long_ctype;
 }
 
diff --git a/target-sparc.c b/target-sparc.c
index be4e968ec604..d830f6cbe828 100644
--- a/target-sparc.c
+++ b/target-sparc.c
@@ -19,6 +19,11 @@ static void predefine_sparc(const struct target *self)
 
 static void init_sparc32(const struct target *target)
 {
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+
 	if (!sparc_version)
 		sparc_version = 8;
 
diff --git a/target-x86.c b/target-x86.c
index 956af92efe4e..e69594edac0e 100644
--- a/target-x86.c
+++ b/target-x86.c
@@ -33,6 +33,8 @@ static void init_x86_common(const struct target *target)
 		ssize_t_ctype = &long_ctype;
 		wchar_ctype = &int_ctype;
 		wint_ctype = &int_ctype;
+		fast16_ctype = &short_ctype;
+		ufast16_ctype = &ushort_ctype;
 		break;
 	}
 }
@@ -40,6 +42,11 @@ static void init_x86_common(const struct target *target)
 
 static void init_i386(const struct target *target)
 {
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+
 	init_x86_common(target);
 }
 
@@ -71,13 +78,31 @@ static void init_x86_64(const struct target *target)
 		int64_ctype = &llong_ctype;
 		uint64_ctype = &ullong_ctype;
 		wint_ctype = &int_ctype;
+		fast16_ctype = &short_ctype;
+		ufast16_ctype = &ushort_ctype;
+		fast32_ctype = &int_ctype;
+		ufast32_ctype = &uint_ctype;
+		fast64_ctype = &llong_ctype;
+		ufast64_ctype = &ullong_ctype;
 		break;
 	case OS_FREEBSD:
+		fast16_ctype = &short_ctype;
+		ufast16_ctype = &ushort_ctype;
+		fast32_ctype = &int_ctype;
+		ufast32_ctype = &uint_ctype;
 		break;
 	case OS_NETBSD:
+		fast8_ctype = &int_ctype;
+		ufast8_ctype = &uint_ctype;
+		fast16_ctype = &int_ctype;
+		ufast16_ctype = &uint_ctype;
+		fast32_ctype = &int_ctype;
+		ufast32_ctype = &uint_ctype;
 		wint_ctype = &int_ctype;
 		break;
 	case OS_OPENBSD:
+		fast32_ctype = &int_ctype;
+		ufast32_ctype = &uint_ctype;
 		int64_ctype = &llong_ctype;
 		uint64_ctype = &ullong_ctype;
 		intmax_ctype = &llong_ctype;
diff --git a/target-xtensa.c b/target-xtensa.c
index 3e5781c86d82..26bda47f02f0 100644
--- a/target-xtensa.c
+++ b/target-xtensa.c
@@ -5,6 +5,11 @@
 
 static void init_xtensa(const struct target *self)
 {
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+
 	wchar_ctype = &long_ctype;
 }
 
diff --git a/target.c b/target.c
index e2eb78e25328..655a1527f93f 100644
--- a/target.c
+++ b/target.c
@@ -23,6 +23,14 @@ struct symbol *least32_ctype = &int_ctype;
 struct symbol *uleast32_ctype = &uint_ctype;
 struct symbol *least64_ctype = &llong_ctype;
 struct symbol *uleast64_ctype = &ullong_ctype;
+struct symbol *fast8_ctype = &schar_ctype;
+struct symbol *ufast8_ctype = &uchar_ctype;
+struct symbol *fast16_ctype = &long_ctype;
+struct symbol *ufast16_ctype = &ulong_ctype;
+struct symbol *fast32_ctype = &long_ctype;
+struct symbol *ufast32_ctype = &ulong_ctype;
+struct symbol *fast64_ctype = &long_ctype;
+struct symbol *ufast64_ctype = &ulong_ctype;
 
 /*
  * For "__attribute__((aligned))"
@@ -214,6 +222,8 @@ void target_init(void)
 		uint64_ctype = &ullong_ctype;
 		intmax_ctype = &llong_ctype;
 		uintmax_ctype = &ullong_ctype;
+		fast64_ctype = &llong_ctype;
+		ufast64_ctype = &ullong_ctype;
 		if (target->target_32bit)
 			target = target->target_32bit;
 		break;
diff --git a/target.h b/target.h
index 4140b77c4beb..3fdfc1e69339 100644
--- a/target.h
+++ b/target.h
@@ -21,6 +21,14 @@ extern struct symbol *least32_ctype;
 extern struct symbol *uleast32_ctype;
 extern struct symbol *least64_ctype;
 extern struct symbol *uleast64_ctype;
+extern struct symbol *fast8_ctype;
+extern struct symbol *ufast8_ctype;
+extern struct symbol *fast16_ctype;
+extern struct symbol *ufast16_ctype;
+extern struct symbol *fast32_ctype;
+extern struct symbol *ufast32_ctype;
+extern struct symbol *fast64_ctype;
+extern struct symbol *ufast64_ctype;
 
 /*
  * For "__attribute__((aligned))"
-- 
2.27.0

[PATCH 6/9] predefine: teach sparse about __SIG_ATOMIC_TYPE__

[Luc Van Oostenryck]

This type is predefined by GCC so add it to sparse too.

Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
 predefine.c | 1 +
 target.c    | 1 +
 target.h    | 1 +
 3 files changed, 3 insertions(+)

diff --git a/predefine.c b/predefine.c
index 2e9913d5c0bc..60ecc7070045 100644
--- a/predefine.c
+++ b/predefine.c
@@ -170,6 +170,7 @@ void predefined_macros(void)
 	predefined_ctype("PTRDIFF",  ssize_t_ctype, PTYPE_ALL_T|PTYPE_TYPE);
 	predefined_ctype("SIZE",      size_t_ctype, PTYPE_ALL_T|PTYPE_TYPE);
 	predefined_ctype("POINTER",     &ptr_ctype, PTYPE_SIZEOF);
+	predefined_ctype("SIG_ATOMIC", sig_atomic_ctype, PTYPE_MAX|PTYPE_MIN|PTYPE_TYPE|PTYPE_WIDTH);
 
 	predefined_sizeof("FLOAT", "", bits_in_float);
 	predefined_sizeof("DOUBLE", "", bits_in_double);
diff --git a/target.c b/target.c
index 655a1527f93f..f320ab525dfb 100644
--- a/target.c
+++ b/target.c
@@ -31,6 +31,7 @@ struct symbol *fast32_ctype = &long_ctype;
 struct symbol *ufast32_ctype = &ulong_ctype;
 struct symbol *fast64_ctype = &long_ctype;
 struct symbol *ufast64_ctype = &ulong_ctype;
+struct symbol *sig_atomic_ctype = &int_ctype;
 
 /*
  * For "__attribute__((aligned))"
diff --git a/target.h b/target.h
index 3fdfc1e69339..5bbce397bba5 100644
--- a/target.h
+++ b/target.h
@@ -29,6 +29,7 @@ extern struct symbol *fast32_ctype;
 extern struct symbol *ufast32_ctype;
 extern struct symbol *fast64_ctype;
 extern struct symbol *ufast64_ctype;
+extern struct symbol *sig_atomic_ctype;
 
 /*
  * For "__attribute__((aligned))"
-- 
2.27.0

[PATCH 7/9] arch: allow target specific [u]intptr_t & ptrdiff_t

[Luc Van Oostenryck]

These types are aliased to size_t & ssize_t but this is not
correct for all architectures.

So, add a variable for them so that target files can adjust them.

Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
 predefine.c    | 6 +++---
 symbol.c       | 7 +++++++
 symbol.h       | 3 ---
 target-h8300.c | 2 ++
 target-s390.c  | 3 +++
 target-sh.c    | 2 ++
 target.c       | 3 +++
 target.h       | 3 +++
 8 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/predefine.c b/predefine.c
index 60ecc7070045..7120d4381f16 100644
--- a/predefine.c
+++ b/predefine.c
@@ -165,9 +165,9 @@ void predefined_macros(void)
 
 	predefined_ctype("INTMAX",    intmax_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
 	predefined_ctype("UINTMAX",  uintmax_ctype, PTYPE_MAX|PTYPE_TYPE);
-	predefined_ctype("INTPTR",   ssize_t_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
-	predefined_ctype("UINTPTR",   size_t_ctype, PTYPE_MAX|PTYPE_TYPE);
-	predefined_ctype("PTRDIFF",  ssize_t_ctype, PTYPE_ALL_T|PTYPE_TYPE);
+	predefined_ctype("INTPTR",    intptr_ctype, PTYPE_MAX|PTYPE_TYPE|PTYPE_WIDTH);
+	predefined_ctype("UINTPTR",  uintptr_ctype, PTYPE_MAX|PTYPE_TYPE);
+	predefined_ctype("PTRDIFF",  ptrdiff_ctype, PTYPE_ALL_T|PTYPE_TYPE);
 	predefined_ctype("SIZE",      size_t_ctype, PTYPE_ALL_T|PTYPE_TYPE);
 	predefined_ctype("POINTER",     &ptr_ctype, PTYPE_SIZEOF);
 	predefined_ctype("SIG_ATOMIC", sig_atomic_ctype, PTYPE_MAX|PTYPE_MIN|PTYPE_TYPE|PTYPE_WIDTH);
diff --git a/symbol.c b/symbol.c
index 6ee521ba48d8..c0ca79e42e96 100644
--- a/symbol.c
+++ b/symbol.c
@@ -899,4 +899,11 @@ void init_ctype(void)
 		char_ctype.ctype.modifiers |= MOD_UNSIGNED;
 		char_ctype.ctype.modifiers &= ~MOD_SIGNED;
 	}
+
+	if (!ptrdiff_ctype)
+		ptrdiff_ctype = ssize_t_ctype;
+	if (!intptr_ctype)
+		intptr_ctype = ssize_t_ctype;
+	if (!uintptr_ctype)
+		uintptr_ctype = size_t_ctype;
 }
diff --git a/symbol.h b/symbol.h
index 67464d659cc2..c2b60ce91c27 100644
--- a/symbol.h
+++ b/symbol.h
@@ -304,9 +304,6 @@ extern struct symbol	float128_ctype;
 extern struct symbol	const_void_ctype, const_char_ctype;
 extern struct symbol	const_ptr_ctype, const_string_ctype;
 
-#define	uintptr_ctype	 size_t_ctype
-#define	 intptr_ctype	ssize_t_ctype
-
 /* Special internal symbols */
 extern struct symbol	zero_int;
 
diff --git a/target-h8300.c b/target-h8300.c
index 84d168b7410a..c3652350bac7 100644
--- a/target-h8300.c
+++ b/target-h8300.c
@@ -5,6 +5,8 @@
 
 static void init_h8300(const struct target *self)
 {
+	intptr_ctype = &int_ctype;
+	uintptr_ctype = &uint_ctype;
 	ssize_t_ctype = &long_ctype;
 	size_t_ctype = &ulong_ctype;
 	wchar_ctype = &ushort_ctype;
diff --git a/target-s390.c b/target-s390.c
index cdbd685a2099..84889c0aa7ad 100644
--- a/target-s390.c
+++ b/target-s390.c
@@ -6,6 +6,9 @@
 
 static void init_s390(const struct target *self)
 {
+	intptr_ctype = &int_ctype;
+	uintptr_ctype = &uint_ctype;
+
 	fast16_ctype = &int_ctype;
 	ufast16_ctype = &uint_ctype;
 	fast32_ctype = &int_ctype;
diff --git a/target-sh.c b/target-sh.c
index d4ddf45504cf..d3a66180a0aa 100644
--- a/target-sh.c
+++ b/target-sh.c
@@ -7,6 +7,8 @@ static void init_sh(const struct target *self)
 {
 	int64_ctype = &llong_ctype;
 	uint64_ctype = &ullong_ctype;
+	intptr_ctype = &int_ctype;
+	uintptr_ctype = &uint_ctype;
 
 	fast16_ctype = &int_ctype;
 	ufast16_ctype = &uint_ctype;
diff --git a/target.c b/target.c
index f320ab525dfb..308386b8fa7d 100644
--- a/target.c
+++ b/target.c
@@ -5,6 +5,9 @@
 #include "target.h"
 #include "machine.h"
 
+struct symbol *ptrdiff_ctype;
+struct symbol *intptr_ctype;
+struct symbol *uintptr_ctype;
 struct symbol *size_t_ctype = &ulong_ctype;
 struct symbol *ssize_t_ctype = &long_ctype;
 struct symbol *intmax_ctype = &long_ctype;
diff --git a/target.h b/target.h
index 5bbce397bba5..8ffd8e882906 100644
--- a/target.h
+++ b/target.h
@@ -5,6 +5,9 @@
 
 extern struct symbol *size_t_ctype;
 extern struct symbol *ssize_t_ctype;
+extern struct symbol *ptrdiff_ctype;
+extern struct symbol *intptr_ctype;
+extern struct symbol *uintptr_ctype;
 extern struct symbol *intmax_ctype;
 extern struct symbol *uintmax_ctype;
 extern struct symbol *int64_ctype;
-- 
2.27.0

[PATCH 8/9] x86-x32: fix it by defining a separate target for it

[Luc Van Oostenryck]

On x86-64, the x32 ABI was processed as a kind of special case
of the usual 32-bit variant. But this doesn't work very well.

Fix it and help avoiding possible future problems by defining
a separate target for it.

Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
 target-x86.c | 32 ++++++++++++++++++++++++++++++++
 target.c     | 11 ++++++++---
 target.h     |  1 +
 3 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/target-x86.c b/target-x86.c
index e69594edac0e..b7ff8f2ab4ed 100644
--- a/target-x86.c
+++ b/target-x86.c
@@ -67,6 +67,37 @@ const struct target target_i386 = {
 };
 
 
+static void init_x86_x32(const struct target *target)
+{
+	init_x86_common(target);
+
+	max_int_alignment = 8;
+
+	fast16_ctype = &int_ctype;
+	ufast16_ctype = &uint_ctype;
+	fast32_ctype = &int_ctype;
+	ufast32_ctype = &uint_ctype;
+	wchar_ctype = &long_ctype;
+}
+
+static const struct target target_x86_x32 = {
+	.mach = MACH_X86_64,
+	.bitness = ARCH_X32,
+	.big_endian = 0,
+	.unsigned_char = 0,
+	.has_int128 = 1,
+
+	.bits_in_longdouble = 128,
+	.max_fp_alignment = 16,
+
+	.target_32bit = &target_i386,
+	.target_64bit = &target_x86_64,
+
+	.init = init_x86_x32,
+	.predefine = predefine_x86_64,
+};
+
+
 static void init_x86_64(const struct target *target)
 {
 	init_x86_common(target);
@@ -124,6 +155,7 @@ const struct target target_x86_64 = {
 	.max_fp_alignment = 16,
 
 	.target_32bit = &target_i386,
+	.target_x32bit = &target_x86_x32,
 
 	.init = init_x86_64,
 	.predefine = predefine_x86_64,
diff --git a/target.c b/target.c
index 308386b8fa7d..8ae22d744f40 100644
--- a/target.c
+++ b/target.c
@@ -213,10 +213,17 @@ void target_init(void)
 	const struct target *target = arch_target;
 
 	switch (arch_m64) {
+	case ARCH_X32:
+		if (target->target_x32bit)
+			target = target->target_x32bit;
+		goto case_32bit;
+
 	case ARCH_LP32:
 		max_int_alignment = 4;
+		if (target->target_32bit)
+			target = target->target_32bit;
 		/* fallthrough */
-	case ARCH_X32:
+	case_32bit:
 		bits_in_long = 32;
 		bits_in_pointer = 32;
 		pointer_alignment = 4;
@@ -228,8 +235,6 @@ void target_init(void)
 		uintmax_ctype = &ullong_ctype;
 		fast64_ctype = &llong_ctype;
 		ufast64_ctype = &ullong_ctype;
-		if (target->target_32bit)
-			target = target->target_32bit;
 		break;
 
 	case ARCH_LLP64:
diff --git a/target.h b/target.h
index 8ffd8e882906..92b8af9169d7 100644
--- a/target.h
+++ b/target.h
@@ -92,6 +92,7 @@ struct target {
 	unsigned int	max_fp_alignment;
 
 	const struct target *target_32bit;
+	const struct target *target_x32bit;
 	const struct target *target_64bit;
 
 	const struct builtin_fn *builtins;
-- 
2.27.0

[PATCH 9/9] predefine: let predefine_width() take the usual interface

[Luc Van Oostenryck]

All the helpers for type-related predefines directly take in
argument the pointer to the type. All but predefine_width().
This must be an historical relic.

So, let predefine_width() to also take the pointer to the type
in argument.

Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
 predefine.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/predefine.c b/predefine.c
index 7120d4381f16..f898cdfa39b8 100644
--- a/predefine.c
+++ b/predefine.c
@@ -25,12 +25,12 @@ static void predefined_sizeof(const char *name, const char *suffix, unsigned bit
 	predefine(buf, 1, "%d", bits/8);
 }
 
-static void predefined_width(const char *name, unsigned bits)
+static void predefined_width(const char *name, struct symbol *type)
 {
 	char buf[32];
 
 	snprintf(buf, sizeof(buf), "__%s_WIDTH__", name);
-	predefine(buf, 1, "%d", bits);
+	predefine(buf, 1, "%d", type->bit_size);
 }
 
 static void predefined_max(const char *name, struct symbol *type)
@@ -78,7 +78,7 @@ static void predefined_ctype(const char *name, struct symbol *type, int flags)
 	if (flags & PTYPE_TYPE)
 		predefined_type(name, type);
 	if (flags & PTYPE_WIDTH)
-		predefined_width(name, bits);
+		predefined_width(name, type);
 }
 
 void predefined_macros(void)
-- 
2.27.0