[dpkg] / m4 / dpkg-compiler.m4

# Copyright © 2004 Scott James Remnant <scott@netsplit.com>
# Copyright © 2006, 2009-2011, 2013-2016 Guillem Jover <guillem@debian.org>

# DPKG_CHECK_COMPILER_FLAG
# ------------------------
AC_DEFUN([DPKG_CHECK_COMPILER_FLAG], [
  m4_define([dpkg_check_flag], [m4_default([$2], [$1])])

  AC_LANG_CASE(
  [C], [
    m4_define([dpkg_compiler], [$CC])
    m4_define([dpkg_varname], [CFLAGS])
    m4_define([dpkg_varname_save], [dpkg_save_CFLAGS])
    m4_define([dpkg_varname_export], [COMPILER_CFLAGS])
    AS_VAR_PUSHDEF([dpkg_varname_cache], [dpkg_cv_cflags_$1])
  ],
  [C++], [
    m4_define([dpkg_compiler], [$CXX])
    m4_define([dpkg_varname], [CXXFLAGS])
    m4_define([dpkg_varname_save], [dpkg_save_CXXFLAGS])
    m4_define([dpkg_varname_export], [COMPILER_CXXFLAGS])
    AS_VAR_PUSHDEF([dpkg_varname_cache], [dpkg_cv_cxxflags_$1])
  ])
  AC_CACHE_CHECK([whether ]dpkg_compiler[ accepts $1], [dpkg_varname_cache], [
    AS_VAR_COPY([dpkg_varname_save], [dpkg_varname])
    AS_VAR_SET([dpkg_varname], ["-Werror dpkg_check_flag"])
    AC_COMPILE_IFELSE([
      AC_LANG_SOURCE([[]])
    ], [
      AS_VAR_SET([dpkg_varname_cache], [yes])
    ], [
      AS_VAR_SET([dpkg_varname_cache], [no])
    ])
    AS_VAR_COPY([dpkg_varname], [dpkg_varname_save])
  ])
  AS_VAR_IF([dpkg_varname_cache], [yes], [
    AS_VAR_APPEND([dpkg_varname_export], [" $1"])
  ])
  AS_VAR_POPDEF([dpkg_varname_cache])
])

# DPKG_CHECK_COMPILER_WARNINGS
# ----------------------------
# Add configure option to disable additional compiler warnings.
AC_DEFUN([DPKG_CHECK_COMPILER_WARNINGS], [
  DPKG_CHECK_COMPILER_FLAG([-Wall])
  DPKG_CHECK_COMPILER_FLAG([-Wextra])
  DPKG_CHECK_COMPILER_FLAG([-Wno-unused-parameter], [-Wunused-parameter])
  DPKG_CHECK_COMPILER_FLAG([-Wno-missing-field-initializers],
                           [-Wmissing-field-initializers])
  DPKG_CHECK_COMPILER_FLAG([-Wno-tautological-constant-out-of-range-compare],
                           [-Wtautological-constant-out-of-range-compare])
  DPKG_CHECK_COMPILER_FLAG([-Wmissing-declarations])
  DPKG_CHECK_COMPILER_FLAG([-Wmissing-format-attribute])
  DPKG_CHECK_COMPILER_FLAG([-Wformat -Wformat-security])
  DPKG_CHECK_COMPILER_FLAG([-Wsizeof-array-argument])
  DPKG_CHECK_COMPILER_FLAG([-Wpointer-arith])
  DPKG_CHECK_COMPILER_FLAG([-Wlogical-op])
  DPKG_CHECK_COMPILER_FLAG([-Wlogical-not-parentheses])
  DPKG_CHECK_COMPILER_FLAG([-Wswitch-bool])
  DPKG_CHECK_COMPILER_FLAG([-Wvla])
  DPKG_CHECK_COMPILER_FLAG([-Winit-self])
  DPKG_CHECK_COMPILER_FLAG([-Wwrite-strings])
  DPKG_CHECK_COMPILER_FLAG([-Wcast-align])
  DPKG_CHECK_COMPILER_FLAG([-Wshadow])
  DPKG_CHECK_COMPILER_FLAG([-Wduplicated-cond])
  DPKG_CHECK_COMPILER_FLAG([-Wnull-dereference])

  AC_LANG_CASE(
  [C], [
    DPKG_CHECK_COMPILER_FLAG([-Wdeclaration-after-statement])
    DPKG_CHECK_COMPILER_FLAG([-Wnested-externs])
    DPKG_CHECK_COMPILER_FLAG([-Wbad-function-cast])
    DPKG_CHECK_COMPILER_FLAG([-Wstrict-prototypes])
    DPKG_CHECK_COMPILER_FLAG([-Wmissing-prototypes])
    DPKG_CHECK_COMPILER_FLAG([-Wold-style-definition])
    DPKG_CHECK_COMPILER_FLAG([-Wc99-c11-compat])
  ],
  [C++], [
    DPKG_CHECK_COMPILER_FLAG([-Wc++11-compat])
    AS_IF([test "x$dpkg_cv_cxx11" = "xyes"], [
      DPKG_CHECK_COMPILER_FLAG([-Wzero-as-null-pointer-constant])
    ])
  ])
])

# DPKG_COMPILER_WARNINGS
# ----------------------
# Add configure option to disable additional compiler warnings.
AC_DEFUN([DPKG_COMPILER_WARNINGS], [
  AC_ARG_ENABLE([compiler-warnings],
    [AS_HELP_STRING([--disable-compiler-warnings],
      [Disable (detected) additional compiler warnings])],
    [], [enable_compiler_warnings=yes])

  AS_IF([test "x$enable_compiler_warnings" = "xyes"], [
    DPKG_CHECK_COMPILER_WARNINGS
    AC_LANG_PUSH([C++])
    DPKG_CHECK_COMPILER_WARNINGS
    AC_LANG_POP([C++])

    CFLAGS="$COMPILER_CFLAGS $CFLAGS"
    CXXFLAGS="$COMPILER_CXXFLAGS $CXXFLAGS"
  ])
])

# DPKG_COMPILER_OPTIMIZATIONS
# ---------------------------
# Add configure option to disable optimizations.
AC_DEFUN([DPKG_COMPILER_OPTIMIZATIONS], [
  AC_ARG_ENABLE([compiler-optimizations],
    [AS_HELP_STRING([--disable-compiler-optimizations],
      [Disable (detected) compiler optimizations])],
    [], [enable_compiler_optimizations=yes])

  AS_IF([test "x$enable_compiler_optimizations" = "xno"], [
    CFLAGS=$(echo "$CFLAGS" | sed -e "s/ -O[[1-9]]*\b/ -O0/g")
  ])
])

# DPKG_TRY_C99([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
# ------------------------------------------------------
# Try compiling some C99 code to see whether it works
AC_DEFUN([DPKG_TRY_C99], [
  AC_COMPILE_IFELSE([
    AC_LANG_PROGRAM([[
#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>

/* Variadic macro arguments. */
#define variadic_macro(foo, ...) printf(foo, __VA_ARGS__)
    ]], [[
	int rc;

	/* Designated initializers. */
	struct { int a, b; } foo = { .a = 1, .b = 2 };

	/* Compound literals. */
	struct point { int x, y; } p = (struct point){ .x = 0, .y = 1 };
	p = (struct point){ .x = 2, .y = 4 };

	/* Trailing comma in enum. */
	enum { FIRST, SECOND, } quux;

	/* Boolean type. */
	bool bar = false;

	/* Specific size type. */
	uint32_t baz = 0;
	size_t size = SIZE_MAX;
	intmax_t imax = INTMAX_MAX;

	/* Format modifiers. */
	rc = printf("%jd", imax);
	if (rc == 3)
		return 1;
	rc = printf("%zu", size);
	if (rc == 3)
		return 1;

	/* Magic __func__ variable. */
	printf("%s", __func__);
    ]])
  ], [$1], [$2])dnl
])# DPKG_TRY_C99

# DPKG_C_C99
# ----------
# Check whether the compiler can do C99
AC_DEFUN([DPKG_C_C99], [
  AC_CACHE_CHECK([whether $CC supports C99 features], [dpkg_cv_c99], [
    DPKG_TRY_C99([dpkg_cv_c99=yes], [dpkg_cv_c99=no])
  ])
  AS_IF([test "x$dpkg_cv_c99" != "xyes"], [
    AC_CACHE_CHECK([for $CC option to accept C99 features], [dpkg_cv_c99_arg], [
      dpkg_cv_c99_arg=none
      dpkg_save_CC="$CC"
      for arg in "-std=gnu99" "-std=c99" "-c99" "-AC99" "-xc99=all" \
                 "-qlanglvl=extc99"; do
        CC="$dpkg_save_CC $arg"
        DPKG_TRY_C99([dpkg_arg_worked=yes], [dpkg_arg_worked=no])
        CC="$dpkg_save_CC"

        AS_IF([test "x$dpkg_arg_worked" = "xyes"], [
          dpkg_cv_c99_arg="$arg"
          break
        ])
      done
    ])
    AS_IF([test "x$dpkg_cv_c99_arg" != "xnone"], [
      CC="$CC $dpkg_cv_c99_arg"
      dpkg_cv_c99=1
    ])
  ])
  AS_IF([test "x$dpkg_cv_c99" = "xyes"], [
    AC_DEFINE([HAVE_C99], 1, [Define to 1 if the compiler supports C99.])
  ], [
    AC_MSG_ERROR([unsupported required C99 extensions])
  ])
])# DPKG_C_C99

# DPKG_TRY_CXX11([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
# --------------
# Try compiling some C++11 code to see whether it works.
AC_DEFUN([DPKG_TRY_CXX11], [
  AC_LANG_PUSH([C++])
  AC_COMPILE_IFELSE([
    AC_LANG_PROGRAM([[
    ]], [[
	// Null pointer keyword.
	void *ptr = nullptr;
    ]])
  ], [$1], [$2])
  AC_LANG_POP([C++])dnl
])# DPKG_TRY_CXX11

# DPKG_CXX_CXX11
# --------------
# Check whether the compiler can do C++11.
AC_DEFUN([DPKG_CXX_CXX11], [
  AC_CACHE_CHECK([whether $CXX supports C++11], [dpkg_cv_cxx11], [
    DPKG_TRY_CXX11([dpkg_cv_cxx11=yes], [dpkg_cv_cxx11=no])
  ])
  AS_IF([test "x$dpkg_cv_cxx11" != "xyes"], [
    AC_CACHE_CHECK([for $CXX option to accept C++11], [dpkg_cv_cxx11_arg], [
      dpkg_cv_cxx11_arg=none
      dpkg_save_CXX="$CXX"
      for arg in "-std=gnu++11" "-std=c++11"; do
        CXX="$dpkg_save_CXX $arg"
        DPKG_TRY_CXX11([dpkg_arg_worked=yes], [dpkg_arg_worked=no])
        CXX="$dpkg_save_CXX"

        AS_IF([test "x$dpkg_arg_worked" = "xyes"], [
          dpkg_cv_cxx11_arg="$arg"; break
        ])
      done
    ])
    AS_IF([test "x$dpkg_cv_cxx11_arg" != "xnone"], [
      CXX="$CXX $dpkg_cv_cxx11_arg"
      dpkg_cv_cxx11=yes
    ])
  ])
  AS_IF([test "x$dpkg_cv_cxx11" = "xyes"], [
    AC_DEFINE([HAVE_CXX11], 1, [Define to 1 if the compiler supports C++11.])
  ])[]dnl
])# DPKG_CXX_CXX11
Commit	Line	Data
1479465f GJ	1	# Copyright © 2004 Scott James Remnant <scott@netsplit.com>
	2	# Copyright © 2006, 2009-2011, 2013-2016 Guillem Jover <guillem@debian.org>
	3
	4	# DPKG_CHECK_COMPILER_FLAG
	5	# ------------------------
	6	AC_DEFUN([DPKG_CHECK_COMPILER_FLAG], [
	7	m4_define([dpkg_check_flag], [m4_default([$2], [$1])])
	8
	9	AC_LANG_CASE(
	10	[C], [
	11	m4_define([dpkg_compiler], [$CC])
	12	m4_define([dpkg_varname], [CFLAGS])
	13	m4_define([dpkg_varname_save], [dpkg_save_CFLAGS])
	14	m4_define([dpkg_varname_export], [COMPILER_CFLAGS])
	15	AS_VAR_PUSHDEF([dpkg_varname_cache], [dpkg_cv_cflags_$1])
	16	],
	17	[C++], [
	18	m4_define([dpkg_compiler], [$CXX])
	19	m4_define([dpkg_varname], [CXXFLAGS])
	20	m4_define([dpkg_varname_save], [dpkg_save_CXXFLAGS])
	21	m4_define([dpkg_varname_export], [COMPILER_CXXFLAGS])
	22	AS_VAR_PUSHDEF([dpkg_varname_cache], [dpkg_cv_cxxflags_$1])
	23	])
	24	AC_CACHE_CHECK([whether ]dpkg_compiler[ accepts $1], [dpkg_varname_cache], [
	25	AS_VAR_COPY([dpkg_varname_save], [dpkg_varname])
	26	AS_VAR_SET([dpkg_varname], ["-Werror dpkg_check_flag"])
	27	AC_COMPILE_IFELSE([
	28	AC_LANG_SOURCE([[]])
	29	], [
	30	AS_VAR_SET([dpkg_varname_cache], [yes])
	31	], [
	32	AS_VAR_SET([dpkg_varname_cache], [no])
	33	])
	34	AS_VAR_COPY([dpkg_varname], [dpkg_varname_save])
	35	])
	36	AS_VAR_IF([dpkg_varname_cache], [yes], [
	37	AS_VAR_APPEND([dpkg_varname_export], [" $1"])
	38	])
	39	AS_VAR_POPDEF([dpkg_varname_cache])
	40	])
	41
	42	# DPKG_CHECK_COMPILER_WARNINGS
	43	# ----------------------------
	44	# Add configure option to disable additional compiler warnings.
	45	AC_DEFUN([DPKG_CHECK_COMPILER_WARNINGS], [
	46	DPKG_CHECK_COMPILER_FLAG([-Wall])
	47	DPKG_CHECK_COMPILER_FLAG([-Wextra])
	48	DPKG_CHECK_COMPILER_FLAG([-Wno-unused-parameter], [-Wunused-parameter])
	49	DPKG_CHECK_COMPILER_FLAG([-Wno-missing-field-initializers],
	50	[-Wmissing-field-initializers])
	51	DPKG_CHECK_COMPILER_FLAG([-Wno-tautological-constant-out-of-range-compare],
	52	[-Wtautological-constant-out-of-range-compare])
	53	DPKG_CHECK_COMPILER_FLAG([-Wmissing-declarations])
	54	DPKG_CHECK_COMPILER_FLAG([-Wmissing-format-attribute])
	55	DPKG_CHECK_COMPILER_FLAG([-Wformat -Wformat-security])
	56	DPKG_CHECK_COMPILER_FLAG([-Wsizeof-array-argument])
	57	DPKG_CHECK_COMPILER_FLAG([-Wpointer-arith])
	58	DPKG_CHECK_COMPILER_FLAG([-Wlogical-op])
	59	DPKG_CHECK_COMPILER_FLAG([-Wlogical-not-parentheses])
	60	DPKG_CHECK_COMPILER_FLAG([-Wswitch-bool])
	61	DPKG_CHECK_COMPILER_FLAG([-Wvla])
	62	DPKG_CHECK_COMPILER_FLAG([-Winit-self])
	63	DPKG_CHECK_COMPILER_FLAG([-Wwrite-strings])
	64	DPKG_CHECK_COMPILER_FLAG([-Wcast-align])
65	DPKG_CHECK_COMPILER_FLAG([-Wshadow])
66	DPKG_CHECK_COMPILER_FLAG([-Wduplicated-cond])
67	DPKG_CHECK_COMPILER_FLAG([-Wnull-dereference])
68
69	AC_LANG_CASE(
70	[C], [
71	DPKG_CHECK_COMPILER_FLAG([-Wdeclaration-after-statement])
72	DPKG_CHECK_COMPILER_FLAG([-Wnested-externs])
73	DPKG_CHECK_COMPILER_FLAG([-Wbad-function-cast])
74	DPKG_CHECK_COMPILER_FLAG([-Wstrict-prototypes])
75	DPKG_CHECK_COMPILER_FLAG([-Wmissing-prototypes])
76	DPKG_CHECK_COMPILER_FLAG([-Wold-style-definition])
77	DPKG_CHECK_COMPILER_FLAG([-Wc99-c11-compat])
78	],
79	[C++], [
80	DPKG_CHECK_COMPILER_FLAG([-Wc++11-compat])
81	AS_IF([test "x$dpkg_cv_cxx11" = "xyes"], [
82	DPKG_CHECK_COMPILER_FLAG([-Wzero-as-null-pointer-constant])
83	])
84	])
85	])
86
87	# DPKG_COMPILER_WARNINGS
88	# ----------------------
89	# Add configure option to disable additional compiler warnings.
90	AC_DEFUN([DPKG_COMPILER_WARNINGS], [
91	AC_ARG_ENABLE([compiler-warnings],
92	[AS_HELP_STRING([--disable-compiler-warnings],
93	[Disable (detected) additional compiler warnings])],
94	[], [enable_compiler_warnings=yes])
95
96	AS_IF([test "x$enable_compiler_warnings" = "xyes"], [
97	DPKG_CHECK_COMPILER_WARNINGS
98	AC_LANG_PUSH([C++])
99	DPKG_CHECK_COMPILER_WARNINGS
100	AC_LANG_POP([C++])
101
102	CFLAGS="$COMPILER_CFLAGS $CFLAGS"
103	CXXFLAGS="$COMPILER_CXXFLAGS $CXXFLAGS"
104	])
105	])
106
107	# DPKG_COMPILER_OPTIMIZATIONS
108	# ---------------------------
109	# Add configure option to disable optimizations.
110	AC_DEFUN([DPKG_COMPILER_OPTIMIZATIONS], [
111	AC_ARG_ENABLE([compiler-optimizations],
112	[AS_HELP_STRING([--disable-compiler-optimizations],
113	[Disable (detected) compiler optimizations])],
114	[], [enable_compiler_optimizations=yes])
115
116	AS_IF([test "x$enable_compiler_optimizations" = "xno"], [
117	CFLAGS=$(echo "$CFLAGS" \| sed -e "s/ -O[[1-9]]*\b/ -O0/g")
118	])
119	])
120
121	# DPKG_TRY_C99([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
122	# ------------------------------------------------------
123	# Try compiling some C99 code to see whether it works
124	AC_DEFUN([DPKG_TRY_C99], [
125	AC_COMPILE_IFELSE([
126	AC_LANG_PROGRAM([[
127	#include <inttypes.h>
128	#include <stdbool.h>
129	#include <stdio.h>
130
131	/* Variadic macro arguments. */
132	#define variadic_macro(foo, ...) printf(foo, __VA_ARGS__)
133	]], [[
134	int rc;
135
136	/* Designated initializers. */
137	struct { int a, b; } foo = { .a = 1, .b = 2 };
138
139	/* Compound literals. */
140	struct point { int x, y; } p = (struct point){ .x = 0, .y = 1 };
141	p = (struct point){ .x = 2, .y = 4 };
142
143	/* Trailing comma in enum. */
144	enum { FIRST, SECOND, } quux;
145
146	/* Boolean type. */
147	bool bar = false;
148
149	/* Specific size type. */
150	uint32_t baz = 0;
151	size_t size = SIZE_MAX;
152	intmax_t imax = INTMAX_MAX;
153
154	/* Format modifiers. */
155	rc = printf("%jd", imax);
156	if (rc == 3)
157	return 1;
158	rc = printf("%zu", size);
159	if (rc == 3)
160	return 1;
161
162	/* Magic __func__ variable. */
163	printf("%s", __func__);
164	]])
165	], [$1], [$2])dnl
166	])# DPKG_TRY_C99
167
168	# DPKG_C_C99
169	# ----------
170	# Check whether the compiler can do C99
171	AC_DEFUN([DPKG_C_C99], [
172	AC_CACHE_CHECK([whether $CC supports C99 features], [dpkg_cv_c99], [
173	DPKG_TRY_C99([dpkg_cv_c99=yes], [dpkg_cv_c99=no])
174	])
175	AS_IF([test "x$dpkg_cv_c99" != "xyes"], [
176	AC_CACHE_CHECK([for $CC option to accept C99 features], [dpkg_cv_c99_arg], [
177	dpkg_cv_c99_arg=none
178	dpkg_save_CC="$CC"
179	for arg in "-std=gnu99" "-std=c99" "-c99" "-AC99" "-xc99=all" \
180	"-qlanglvl=extc99"; do
181	CC="$dpkg_save_CC $arg"
182	DPKG_TRY_C99([dpkg_arg_worked=yes], [dpkg_arg_worked=no])
183	CC="$dpkg_save_CC"
184
185	AS_IF([test "x$dpkg_arg_worked" = "xyes"], [
186	dpkg_cv_c99_arg="$arg"
187	break
188	])
189	done
190	])
191	AS_IF([test "x$dpkg_cv_c99_arg" != "xnone"], [
192	CC="$CC $dpkg_cv_c99_arg"
193	dpkg_cv_c99=1
194	])
195	])
196	AS_IF([test "x$dpkg_cv_c99" = "xyes"], [
197	AC_DEFINE([HAVE_C99], 1, [Define to 1 if the compiler supports C99.])
198	], [
199	AC_MSG_ERROR([unsupported required C99 extensions])
200	])
201	])# DPKG_C_C99
202
203	# DPKG_TRY_CXX11([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
204	# --------------
205	# Try compiling some C++11 code to see whether it works.
206	AC_DEFUN([DPKG_TRY_CXX11], [
207	AC_LANG_PUSH([C++])
208	AC_COMPILE_IFELSE([
209	AC_LANG_PROGRAM([[
210	]], [[
211	// Null pointer keyword.
212	void *ptr = nullptr;
213	]])
214	], [$1], [$2])
215	AC_LANG_POP([C++])dnl
216	])# DPKG_TRY_CXX11
217
218	# DPKG_CXX_CXX11
219	# --------------
220	# Check whether the compiler can do C++11.
221	AC_DEFUN([DPKG_CXX_CXX11], [
222	AC_CACHE_CHECK([whether $CXX supports C++11], [dpkg_cv_cxx11], [
223	DPKG_TRY_CXX11([dpkg_cv_cxx11=yes], [dpkg_cv_cxx11=no])
224	])
225	AS_IF([test "x$dpkg_cv_cxx11" != "xyes"], [
226	AC_CACHE_CHECK([for $CXX option to accept C++11], [dpkg_cv_cxx11_arg], [
227	dpkg_cv_cxx11_arg=none
228	dpkg_save_CXX="$CXX"
229	for arg in "-std=gnu++11" "-std=c++11"; do
230	CXX="$dpkg_save_CXX $arg"
231	DPKG_TRY_CXX11([dpkg_arg_worked=yes], [dpkg_arg_worked=no])
232	CXX="$dpkg_save_CXX"
233
234	AS_IF([test "x$dpkg_arg_worked" = "xyes"], [
235	dpkg_cv_cxx11_arg="$arg"; break
236	])
237	done
238	])
239	AS_IF([test "x$dpkg_cv_cxx11_arg" != "xnone"], [
240	CXX="$CXX $dpkg_cv_cxx11_arg"
241	dpkg_cv_cxx11=yes
242	])
243	])
244	AS_IF([test "x$dpkg_cv_cxx11" = "xyes"], [
245	AC_DEFINE([HAVE_CXX11], 1, [Define to 1 if the compiler supports C++11.])
246	])[]dnl
247	])# DPKG_CXX_CXX11