15263807472

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <sys/utsname.h>

#include "architecture.h"
#include "string-table.h"
#include "string-util.h"

Architecture uname_architecture(void) {

        /* Return a sanitized enum identifying the architecture we are running on. This
         * is based on uname(), and the user may hence control what this returns by using
         * personality(). This puts the user in control on systems that can run binaries
         * of multiple architectures.
         *
         * We do not translate the string returned by uname() 1:1. Instead we try to
         * clean it up and break down the confusion on x86 and arm in particular.
         *
         * We try to distinguish CPUs, not CPU features, i.e. actual architectures that
         * have genuinely different code. */

        static const struct {
                const char *machine;
                Architecture arch;
        } arch_map[] = {
#if defined(__aarch64__) || defined(__arm__)
                { "aarch64",    ARCHITECTURE_ARM64    },
                { "aarch64_be", ARCHITECTURE_ARM64_BE },
                { "armv8l",     ARCHITECTURE_ARM      },
                { "armv8b",     ARCHITECTURE_ARM_BE   },
                { "armv7ml",    ARCHITECTURE_ARM      },
                { "armv7mb",    ARCHITECTURE_ARM_BE   },
                { "armv7l",     ARCHITECTURE_ARM      },
                { "armv7b",     ARCHITECTURE_ARM_BE   },
                { "armv6l",     ARCHITECTURE_ARM      },
                { "armv6b",     ARCHITECTURE_ARM_BE   },
                { "armv5tl",    ARCHITECTURE_ARM      },
                { "armv5tel",   ARCHITECTURE_ARM      },
                { "armv5tejl",  ARCHITECTURE_ARM      },
                { "armv5tejb",  ARCHITECTURE_ARM_BE   },
                { "armv5teb",   ARCHITECTURE_ARM_BE   },
                { "armv5tb",    ARCHITECTURE_ARM_BE   },
                { "armv4tl",    ARCHITECTURE_ARM      },
                { "armv4tb",    ARCHITECTURE_ARM_BE   },
                { "armv4l",     ARCHITECTURE_ARM      },
                { "armv4b",     ARCHITECTURE_ARM_BE   },

#elif defined(__alpha__)
                { "alpha" ,     ARCHITECTURE_ALPHA    },

#elif defined(__arc__)
                { "arc",        ARCHITECTURE_ARC      },
                { "arceb",      ARCHITECTURE_ARC_BE   },

#elif defined(__cris__)
                { "crisv32",    ARCHITECTURE_CRIS     },

#elif defined(__i386__) || defined(__x86_64__)
                { "x86_64",     ARCHITECTURE_X86_64   },
                { "i686",       ARCHITECTURE_X86      },
                { "i586",       ARCHITECTURE_X86      },
                { "i486",       ARCHITECTURE_X86      },
                { "i386",       ARCHITECTURE_X86      },

#elif defined(__ia64__)
                { "ia64",       ARCHITECTURE_IA64     },

#elif defined(__hppa__) || defined(__hppa64__)
                { "parisc64",   ARCHITECTURE_PARISC64 },
                { "parisc",     ARCHITECTURE_PARISC   },

#elif defined(__loongarch_lp64)
                { "loongarch64", ARCHITECTURE_LOONGARCH64 },

#elif defined(__m68k__)
                { "m68k",       ARCHITECTURE_M68K     },

#elif defined(__mips__) || defined(__mips64__)
                { "mips64",     ARCHITECTURE_MIPS64   },
                { "mips",       ARCHITECTURE_MIPS     },

#elif defined(__nios2__)
                { "nios2",      ARCHITECTURE_NIOS2    },

#elif defined(__powerpc__) || defined(__powerpc64__)
                { "ppc64le",    ARCHITECTURE_PPC64_LE },
                { "ppc64",      ARCHITECTURE_PPC64    },
                { "ppcle",      ARCHITECTURE_PPC_LE   },
                { "ppc",        ARCHITECTURE_PPC      },

#elif defined(__riscv)
                { "riscv64",    ARCHITECTURE_RISCV64  },
                { "riscv32",    ARCHITECTURE_RISCV32  },
#  if __SIZEOF_POINTER__ == 4
                { "riscv",      ARCHITECTURE_RISCV32  },
#  elif __SIZEOF_POINTER__ == 8
                { "riscv",      ARCHITECTURE_RISCV64  },
#  endif

#elif defined(__s390__) || defined(__s390x__)
                { "s390x",      ARCHITECTURE_S390X    },
                { "s390",       ARCHITECTURE_S390     },

#elif defined(__sh__) || defined(__sh64__)
                { "sh5",        ARCHITECTURE_SH64     },
                { "sh4a",       ARCHITECTURE_SH       },
                { "sh4",        ARCHITECTURE_SH       },
                { "sh3",        ARCHITECTURE_SH       },
                { "sh2a",       ARCHITECTURE_SH       },
                { "sh2",        ARCHITECTURE_SH       },

#elif defined(__sparc__)
                { "sparc64",    ARCHITECTURE_SPARC64  },
                { "sparc",      ARCHITECTURE_SPARC    },

#elif defined(__tilegx__)
                { "tilegx",     ARCHITECTURE_TILEGX   },

#else
#  error "Please register your architecture here!"
#endif
        };

        static Architecture cached = _ARCHITECTURE_INVALID;
        struct utsname u;

        if (cached != _ARCHITECTURE_INVALID)
                return cached;

        assert_se(uname(&u) >= 0);

        FOREACH_ELEMENT(entry, arch_map)
                if (streq(entry->machine, u.machine))
                        return cached = entry->arch;

        assert_not_reached();
        return _ARCHITECTURE_INVALID;
}

/* Maintain same order as in the table above. */
static const char *const architecture_table[_ARCHITECTURE_MAX] = {
        [ARCHITECTURE_ARM64]       = "arm64",
        [ARCHITECTURE_ARM64_BE]    = "arm64-be",
        [ARCHITECTURE_ARM]         = "arm",
        [ARCHITECTURE_ARM_BE]      = "arm-be",
        [ARCHITECTURE_ALPHA]       = "alpha",
        [ARCHITECTURE_ARC]         = "arc",
        [ARCHITECTURE_ARC_BE]      = "arc-be",
        [ARCHITECTURE_CRIS]        = "cris",
        [ARCHITECTURE_X86_64]      = "x86-64",
        [ARCHITECTURE_X86]         = "x86",
        [ARCHITECTURE_IA64]        = "ia64",
        [ARCHITECTURE_LOONGARCH64] = "loongarch64",
        [ARCHITECTURE_M68K]        = "m68k",
        [ARCHITECTURE_MIPS64_LE]   = "mips64-le",
        [ARCHITECTURE_MIPS64]      = "mips64",
        [ARCHITECTURE_MIPS_LE]     = "mips-le",
        [ARCHITECTURE_MIPS]        = "mips",
        [ARCHITECTURE_NIOS2]       = "nios2",
        [ARCHITECTURE_PARISC64]    = "parisc64",
        [ARCHITECTURE_PARISC]      = "parisc",
        [ARCHITECTURE_PPC64_LE]    = "ppc64-le",
        [ARCHITECTURE_PPC64]       = "ppc64",
        [ARCHITECTURE_PPC]         = "ppc",
        [ARCHITECTURE_PPC_LE]      = "ppc-le",
        [ARCHITECTURE_RISCV32]     = "riscv32",
        [ARCHITECTURE_RISCV64]     = "riscv64",
        [ARCHITECTURE_S390X]       = "s390x",
        [ARCHITECTURE_S390]        = "s390",
        [ARCHITECTURE_SH64]        = "sh64",
        [ARCHITECTURE_SH]          = "sh",
        [ARCHITECTURE_SPARC64]     = "sparc64",
        [ARCHITECTURE_SPARC]       = "sparc",
        [ARCHITECTURE_TILEGX]      = "tilegx",
};

DEFINE_STRING_TABLE_LOOKUP(architecture, Architecture);

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <sys/utsname.h>
4
5	#include "architecture.h"
6	#include "string-table.h"
7	#include "string-util.h"
8
9	Architecture uname_architecture(void) {	330✔
10
11	/* Return a sanitized enum identifying the architecture we are running on. This
12	* is based on uname(), and the user may hence control what this returns by using
13	* personality(). This puts the user in control on systems that can run binaries
14	* of multiple architectures.
15	*
16	* We do not translate the string returned by uname() 1:1. Instead we try to
17	* clean it up and break down the confusion on x86 and arm in particular.
18	*
19	* We try to distinguish CPUs, not CPU features, i.e. actual architectures that
20	* have genuinely different code. */
21
22	static const struct {	330✔
23	const char *machine;
24	Architecture arch;
25	} arch_map[] = {
26	#if defined(__aarch64__) \|\| defined(__arm__)
27	{ "aarch64", ARCHITECTURE_ARM64 },
28	{ "aarch64_be", ARCHITECTURE_ARM64_BE },
29	{ "armv8l", ARCHITECTURE_ARM },
30	{ "armv8b", ARCHITECTURE_ARM_BE },
31	{ "armv7ml", ARCHITECTURE_ARM },
32	{ "armv7mb", ARCHITECTURE_ARM_BE },
33	{ "armv7l", ARCHITECTURE_ARM },
34	{ "armv7b", ARCHITECTURE_ARM_BE },
35	{ "armv6l", ARCHITECTURE_ARM },
36	{ "armv6b", ARCHITECTURE_ARM_BE },
37	{ "armv5tl", ARCHITECTURE_ARM },
38	{ "armv5tel", ARCHITECTURE_ARM },
39	{ "armv5tejl", ARCHITECTURE_ARM },
40	{ "armv5tejb", ARCHITECTURE_ARM_BE },
41	{ "armv5teb", ARCHITECTURE_ARM_BE },
42	{ "armv5tb", ARCHITECTURE_ARM_BE },
43	{ "armv4tl", ARCHITECTURE_ARM },
44	{ "armv4tb", ARCHITECTURE_ARM_BE },
45	{ "armv4l", ARCHITECTURE_ARM },
46	{ "armv4b", ARCHITECTURE_ARM_BE },
47
48	#elif defined(__alpha__)
49	{ "alpha" , ARCHITECTURE_ALPHA },
50
51	#elif defined(__arc__)
52	{ "arc", ARCHITECTURE_ARC },
53	{ "arceb", ARCHITECTURE_ARC_BE },
54
55	#elif defined(__cris__)
56	{ "crisv32", ARCHITECTURE_CRIS },
57
58	#elif defined(__i386__) \|\| defined(__x86_64__)
59	{ "x86_64", ARCHITECTURE_X86_64 },
60	{ "i686", ARCHITECTURE_X86 },
61	{ "i586", ARCHITECTURE_X86 },
62	{ "i486", ARCHITECTURE_X86 },
63	{ "i386", ARCHITECTURE_X86 },
64
65	#elif defined(__ia64__)
66	{ "ia64", ARCHITECTURE_IA64 },
67
68	#elif defined(__hppa__) \|\| defined(__hppa64__)
69	{ "parisc64", ARCHITECTURE_PARISC64 },
70	{ "parisc", ARCHITECTURE_PARISC },
71
72	#elif defined(__loongarch_lp64)
73	{ "loongarch64", ARCHITECTURE_LOONGARCH64 },
74
75	#elif defined(__m68k__)
76	{ "m68k", ARCHITECTURE_M68K },
77
78	#elif defined(__mips__) \|\| defined(__mips64__)
79	{ "mips64", ARCHITECTURE_MIPS64 },
80	{ "mips", ARCHITECTURE_MIPS },
81
82	#elif defined(__nios2__)
83	{ "nios2", ARCHITECTURE_NIOS2 },
84
85	#elif defined(__powerpc__) \|\| defined(__powerpc64__)
86	{ "ppc64le", ARCHITECTURE_PPC64_LE },
87	{ "ppc64", ARCHITECTURE_PPC64 },
88	{ "ppcle", ARCHITECTURE_PPC_LE },
89	{ "ppc", ARCHITECTURE_PPC },
90
91	#elif defined(__riscv)
92	{ "riscv64", ARCHITECTURE_RISCV64 },
93	{ "riscv32", ARCHITECTURE_RISCV32 },
94	# if __SIZEOF_POINTER__ == 4
95	{ "riscv", ARCHITECTURE_RISCV32 },
96	# elif __SIZEOF_POINTER__ == 8
97	{ "riscv", ARCHITECTURE_RISCV64 },
98	# endif
99
100	#elif defined(__s390__) \|\| defined(__s390x__)
101	{ "s390x", ARCHITECTURE_S390X },
102	{ "s390", ARCHITECTURE_S390 },
103
104	#elif defined(__sh__) \|\| defined(__sh64__)
105	{ "sh5", ARCHITECTURE_SH64 },
106	{ "sh4a", ARCHITECTURE_SH },
107	{ "sh4", ARCHITECTURE_SH },
108	{ "sh3", ARCHITECTURE_SH },
109	{ "sh2a", ARCHITECTURE_SH },
110	{ "sh2", ARCHITECTURE_SH },
111
112	#elif defined(__sparc__)
113	{ "sparc64", ARCHITECTURE_SPARC64 },
114	{ "sparc", ARCHITECTURE_SPARC },
115
116	#elif defined(__tilegx__)
117	{ "tilegx", ARCHITECTURE_TILEGX },
118
119	#else
120	# error "Please register your architecture here!"
121	#endif
122	};
123
124	static Architecture cached = _ARCHITECTURE_INVALID;	330✔
125	struct utsname u;	330✔
126
127	if (cached != _ARCHITECTURE_INVALID)	330✔
128	return cached;	330✔
129
130	assert_se(uname(&u) >= 0);	243✔
131
132	FOREACH_ELEMENT(entry, arch_map)	243✔
133	if (streq(entry->machine, u.machine))	243✔
134	return cached = entry->arch;	243✔
135
UNCOV 136	assert_not_reached();	×
137	return _ARCHITECTURE_INVALID;
138	}
139
140	/* Maintain same order as in the table above. */
141	static const char *const architecture_table[_ARCHITECTURE_MAX] = {
142	[ARCHITECTURE_ARM64] = "arm64",
143	[ARCHITECTURE_ARM64_BE] = "arm64-be",
144	[ARCHITECTURE_ARM] = "arm",
145	[ARCHITECTURE_ARM_BE] = "arm-be",
146	[ARCHITECTURE_ALPHA] = "alpha",
147	[ARCHITECTURE_ARC] = "arc",
148	[ARCHITECTURE_ARC_BE] = "arc-be",
149	[ARCHITECTURE_CRIS] = "cris",
150	[ARCHITECTURE_X86_64] = "x86-64",
151	[ARCHITECTURE_X86] = "x86",
152	[ARCHITECTURE_IA64] = "ia64",
153	[ARCHITECTURE_LOONGARCH64] = "loongarch64",
154	[ARCHITECTURE_M68K] = "m68k",
155	[ARCHITECTURE_MIPS64_LE] = "mips64-le",
156	[ARCHITECTURE_MIPS64] = "mips64",
157	[ARCHITECTURE_MIPS_LE] = "mips-le",
158	[ARCHITECTURE_MIPS] = "mips",
159	[ARCHITECTURE_NIOS2] = "nios2",
160	[ARCHITECTURE_PARISC64] = "parisc64",
161	[ARCHITECTURE_PARISC] = "parisc",
162	[ARCHITECTURE_PPC64_LE] = "ppc64-le",
163	[ARCHITECTURE_PPC64] = "ppc64",
164	[ARCHITECTURE_PPC] = "ppc",
165	[ARCHITECTURE_PPC_LE] = "ppc-le",
166	[ARCHITECTURE_RISCV32] = "riscv32",
167	[ARCHITECTURE_RISCV64] = "riscv64",
168	[ARCHITECTURE_S390X] = "s390x",
169	[ARCHITECTURE_S390] = "s390",
170	[ARCHITECTURE_SH64] = "sh64",
171	[ARCHITECTURE_SH] = "sh",
172	[ARCHITECTURE_SPARC64] = "sparc64",
173	[ARCHITECTURE_SPARC] = "sparc",
174	[ARCHITECTURE_TILEGX] = "tilegx",
175	};
176
177	DEFINE_STRING_TABLE_LOOKUP(architecture, Architecture);	1,178✔

systemd / systemd / 15263807472

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous