* [kernel-hardening] [PATCH 0/3] Introduce GCC plugin infrastructure
@ 2016-02-07 21:27 Emese Revfy
2016-02-07 21:28 ` [kernel-hardening] [PATCH 1/3] " Emese Revfy
` (2 more replies)
0 siblings, 3 replies; 13+ messages in thread
From: Emese Revfy @ 2016-02-07 21:27 UTC (permalink / raw)
To: linux-kbuild; +Cc: pageexec, spender, kernel-hardening, mmarek, keescook
This patch set introduce the GCC plugin infrastructure with examples for testing
and documentation.
GCC plugins are loadable modules that provide extra features to the compiler.
They are useful for runtime instrumentation and static analysis.
The infrastructure supports all gcc versions from 4.5 to 6.0, building
out-of-tree modules and building in a separate directory. Cross-compilation
is supported too but currently only the x86 architecture enables plugins.
This infrastructure was ported from grsecurity/PaX. It is a CII project
supported by the Linux Foundation.
Emese Revfy (3):
GCC plugin infrastructure
Add Cyclomatic complexity plugin
Documentations of the GCC plugin infrastructre
---
Documentation/dontdiff | 1 +
Documentation/example_gcc_plugin.c | 103 +++++
Documentation/gcc-plugins.txt | 76 ++++
Makefile | 70 +++-
arch/Kconfig | 26 ++
arch/x86/Kconfig | 1 +
init/Makefile | 3 +
scripts/Makefile.build | 2 +-
scripts/Makefile.clean | 3 +-
scripts/Makefile.host | 69 +++-
scripts/gcc-plugin.sh | 51 +++
scripts/link-vmlinux.sh | 2 +-
scripts/package/builddeb | 1 +
tools/gcc/Makefile | 19 +
tools/gcc/cyc_complexity_plugin.c | 120 ++++++
tools/gcc/gcc-common.h | 794 +++++++++++++++++++++++++++++++++++++
16 files changed, 1326 insertions(+), 15 deletions(-)
^ permalink raw reply [flat|nested] 13+ messages in thread* [kernel-hardening] [PATCH 1/3] GCC plugin infrastructure 2016-02-07 21:27 [kernel-hardening] [PATCH 0/3] Introduce GCC plugin infrastructure Emese Revfy @ 2016-02-07 21:28 ` Emese Revfy 2016-02-08 20:28 ` [kernel-hardening] " Michal Marek 2016-02-07 21:31 ` [kernel-hardening] [PATCH 2/3] Add Cyclomatic complexity GCC plugin Emese Revfy 2016-02-07 21:32 ` [kernel-hardening] [PATCH 3/3] Documentation for the GCC plugin infrastructure Emese Revfy 2 siblings, 1 reply; 13+ messages in thread From: Emese Revfy @ 2016-02-07 21:28 UTC (permalink / raw) To: linux-kbuild; +Cc: pageexec, spender, kernel-hardening, mmarek, keescook This patch allows to build the whole kernel with GCC plugins. It was ported from grsecurity/PaX. The infrastructure supports building out-of-tree modules and building in a separate directory. Cross-compilation is supported too but currently only the x86 architecture enables plugins. The directory of the gcc plugins is tools/gcc. You can use a file or a directory there. The plugins compile with these options: * -fno-rtti: gcc is compiled with this option so the plugins must use it too * -fno-exceptions: this is inherited from gcc too * -fasynchronous-unwind-tables: this is inherited from gcc too * -ggdb: it is useful for debugging a plugin (better backtrace on internal errors) * -Wno-narrowing: to suppress warnings from gcc headers (ipa-utils.h) * -Wno-unused-variable: to suppress warnings from gcc headers (gcc_version variable, plugin-version.h) The infrastructure introduces a new Makefile target called gcc-plugins. It supports all gcc versions from 4.5 to 6.0. The scripts/gcc-plugin.sh script chooses the proper host compiler (gcc-4.7 can be built by either gcc or g++). This script also checks the availability of the included headers in tools/gcc/gcc-common.h. The gcc-common.h header contains frequently included headers for GCC plugins and it has a compatibility layer for the supported gcc versions. Note that 'make clean' keeps the *.so files (only the distclean or mrproper targets clean all) because they are needed for out-of-tree modules. --- Documentation/dontdiff | 1 + Makefile | 66 +++- arch/Kconfig | 10 + arch/x86/Kconfig | 1 + init/Makefile | 3 + scripts/Makefile.build | 2 +- scripts/Makefile.clean | 3 +- scripts/Makefile.host | 69 +++- scripts/gcc-plugin.sh | 51 +++ scripts/link-vmlinux.sh | 2 +- scripts/package/builddeb | 1 + tools/gcc/Makefile | 15 + tools/gcc/gcc-common.h | 794 +++++++++++++++++++++++++++++++++++++++++++++++ 13 files changed, 1003 insertions(+), 15 deletions(-) create mode 100644 scripts/gcc-plugin.sh create mode 100644 tools/gcc/Makefile create mode 100644 tools/gcc/gcc-common.h diff --git a/Documentation/dontdiff b/Documentation/dontdiff index 8ea834f..5385cba 100644 --- a/Documentation/dontdiff +++ b/Documentation/dontdiff @@ -3,6 +3,7 @@ *.bc *.bin *.bz2 +*.c.[012]*.* *.cis *.cpio *.csp diff --git a/Makefile b/Makefile index c65fe37..96ce015 100644 --- a/Makefile +++ b/Makefile @@ -434,8 +434,8 @@ export RCS_TAR_IGNORE := --exclude SCCS --exclude BitKeeper --exclude .svn \ # Rules shared between *config targets and build targets # Basic helpers built in scripts/ -PHONY += scripts_basic -scripts_basic: +PHONY += scripts_basic gcc-plugins +scripts_basic: gcc-plugins $(Q)$(MAKE) $(build)=scripts/basic $(Q)rm -f .tmp_quiet_recordmcount @@ -622,6 +622,33 @@ endif # Tell gcc to never replace conditional load with a non-conditional one KBUILD_CFLAGS += $(call cc-option,--param=allow-store-data-races=0) +ifeq ($(call cc-ifversion, -ge, 0408, y), y) +PLUGINCC := $(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-plugin.sh "$(HOSTCXX)" "$(HOSTCXX)" "$(CC)") +else +PLUGINCC := $(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-plugin.sh "$(HOSTCC)" "$(HOSTCXX)" "$(CC)") +endif +ifneq ($(PLUGINCC),) +export PLUGINCC GCC_PLUGINS_CFLAGS GCC_PLUGINS_AFLAGS +ifeq ($(KBUILD_EXTMOD),) +gcc-plugins: + $(Q)$(MAKE) $(build)=tools/gcc +else +gcc-plugins: ; +endif +else +gcc-plugins: +ifeq ($(call cc-ifversion, -ge, 0405, y), y) + $(Q)echo "warning, your gcc installation does not support plugins, perhaps the necessary headers are missing?" +ifeq ($(call cc-ifversion, -ge, 0408, y), y) + $(CONFIG_SHELL) -x $(srctree)/scripts/gcc-plugin.sh "$(HOSTCXX)" "$(HOSTCXX)" "$(CC)" +else + $(CONFIG_SHELL) -x $(srctree)/scripts/gcc-plugin.sh "$(HOSTCC)" "$(HOSTCXX)" "$(CC)" +endif +else + $(Q)echo "warning, your gcc version does not support plugins, you should upgrade it to gcc 4.5 at least" +endif +endif + ifdef CONFIG_READABLE_ASM # Disable optimizations that make assembler listings hard to read. # reorder blocks reorders the control in the function @@ -937,6 +964,8 @@ endif # The actual objects are generated when descending, # make sure no implicit rule kicks in +$(filter-out $(init-y),$(vmlinux-deps)): KBUILD_CFLAGS += $(GCC_PLUGINS_CFLAGS) +$(filter-out $(init-y),$(vmlinux-deps)): KBUILD_AFLAGS += $(GCC_PLUGINS_AFLAGS) $(sort $(vmlinux-deps)): $(vmlinux-dirs) ; # Handle descending into subdirectories listed in $(vmlinux-dirs) @@ -946,7 +975,7 @@ $(sort $(vmlinux-deps)): $(vmlinux-dirs) ; # Error messages still appears in the original language PHONY += $(vmlinux-dirs) -$(vmlinux-dirs): prepare scripts +$(vmlinux-dirs): gcc-plugins prepare scripts $(Q)$(MAKE) $(build)=$@ define filechk_kernel.release @@ -989,10 +1018,13 @@ prepare1: prepare2 $(version_h) include/generated/utsrelease.h \ archprepare: archheaders archscripts prepare1 scripts_basic +prepare0: KBUILD_CFLAGS += $(GCC_PLUGINS_CFLAGS) +prepare0: KBUILD_AFLAGS += $(GCC_PLUGINS_AFLAGS) prepare0: archprepare FORCE $(Q)$(MAKE) $(build)=. # All the preparing.. +prepare: KBUILD_CFLAGS := $(filter-out $(GCC_PLUGINS_CFLAGS),$(KBUILD_CFLAGS)) prepare: prepare0 # Generate some files @@ -1103,6 +1135,8 @@ all: modules # using awk while concatenating to the final file. PHONY += modules +modules: KBUILD_CFLAGS += $(GCC_PLUGINS_CFLAGS) +modules: KBUILD_AFLAGS += $(GCC_PLUGINS_AFLAGS) modules: $(vmlinux-dirs) $(if $(KBUILD_BUILTIN),vmlinux) modules.builtin $(Q)$(AWK) '!x[$$0]++' $(vmlinux-dirs:%=$(objtree)/%/modules.order) > $(objtree)/modules.order @$(kecho) ' Building modules, stage 2.'; @@ -1118,7 +1152,7 @@ modules.builtin: $(vmlinux-dirs:%=%/modules.builtin) # Target to prepare building external modules PHONY += modules_prepare -modules_prepare: prepare scripts +modules_prepare: gcc-plugins prepare scripts # Target to install modules PHONY += modules_install @@ -1223,7 +1257,7 @@ distclean: mrproper @find $(srctree) $(RCS_FIND_IGNORE) \ \( -name '*.orig' -o -name '*.rej' -o -name '*~' \ -o -name '*.bak' -o -name '#*#' -o -name '.*.orig' \ - -o -name '.*.rej' -o -name '*%' -o -name 'core' \) \ + -o -name '.*.rej' -o -name '*.so' -o -name '*%' -o -name 'core' \) \ -type f -print | xargs rm -f @@ -1390,6 +1424,8 @@ PHONY += $(module-dirs) modules $(module-dirs): crmodverdir $(objtree)/Module.symvers $(Q)$(MAKE) $(build)=$(patsubst _module_%,%,$@) +modules: KBUILD_CFLAGS += $(GCC_PLUGINS_CFLAGS) +modules: KBUILD_AFLAGS += $(GCC_PLUGINS_AFLAGS) modules: $(module-dirs) @$(kecho) ' Building modules, stage 2.'; $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost @@ -1531,17 +1567,21 @@ else target-dir = $(if $(KBUILD_EXTMOD),$(dir $<),$(dir $@)) endif -%.s: %.c prepare scripts FORCE +%.s: KBUILD_CFLAGS += $(GCC_PLUGINS_CFLAGS) +%.s: KBUILD_AFLAGS += $(GCC_PLUGINS_AFLAGS) +%.s: %.c gcc-plugins prepare scripts FORCE $(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@) %.i: %.c prepare scripts FORCE $(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@) -%.o: %.c prepare scripts FORCE +%.o: KBUILD_CFLAGS += $(GCC_PLUGINS_CFLAGS) +%.o: KBUILD_AFLAGS += $(GCC_PLUGINS_AFLAGS) +%.o: %.c gcc-plugins prepare scripts FORCE $(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@) %.lst: %.c prepare scripts FORCE $(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@) -%.s: %.S prepare scripts FORCE +%.s: %.S gcc-plugins prepare scripts FORCE $(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@) -%.o: %.S prepare scripts FORCE +%.o: %.S gcc-plugins prepare scripts FORCE $(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@) %.symtypes: %.c prepare scripts FORCE $(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@) @@ -1553,11 +1593,15 @@ endif $(build)=$(build-dir) # Make sure the latest headers are built for Documentation Documentation/: headers_install -%/: prepare scripts FORCE +%/: KBUILD_CFLAGS += $(GCC_PLUGINS_CFLAGS) +%/: KBUILD_AFLAGS += $(GCC_PLUGINS_AFLAGS) +%/: gcc-plugins prepare scripts FORCE $(cmd_crmodverdir) $(Q)$(MAKE) KBUILD_MODULES=$(if $(CONFIG_MODULES),1) \ $(build)=$(build-dir) -%.ko: prepare scripts FORCE +%.ko: KBUILD_CFLAGS += $(GCC_PLUGINS_CFLAGS) +%.ko: KBUILD_AFLAGS += $(GCC_PLUGINS_AFLAGS) +%.ko: gcc-plugins prepare scripts FORCE $(cmd_crmodverdir) $(Q)$(MAKE) KBUILD_MODULES=$(if $(CONFIG_MODULES),1) \ $(build)=$(build-dir) $(@:.ko=.o) diff --git a/arch/Kconfig b/arch/Kconfig index 155e6cd..a95e5b1 100644 --- a/arch/Kconfig +++ b/arch/Kconfig @@ -357,6 +357,16 @@ config SECCOMP_FILTER See Documentation/prctl/seccomp_filter.txt for details. +menu "GCC plugins" + +config HAVE_GCC_PLUGINS + bool + help + An arch should select this symbol if it supports building with + gcc plugins. + +endmenu # "GCC plugins" + config HAVE_CC_STACKPROTECTOR bool help diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 152729c..e51ecd3 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -156,6 +156,7 @@ config X86 select VIRT_TO_BUS select X86_DEV_DMA_OPS if X86_64 select X86_FEATURE_NAMES if PROC_FS + select HAVE_GCC_PLUGINS config INSTRUCTION_DECODER def_bool y diff --git a/init/Makefile b/init/Makefile index 7bc47ee..6da2dc7 100644 --- a/init/Makefile +++ b/init/Makefile @@ -2,6 +2,9 @@ # Makefile for the linux kernel. # +ccflags-y := $(GCC_PLUGINS_CFLAGS) +asflags-y := $(GCC_PLUGINS_AFLAGS) + obj-y := main.o version.o mounts.o ifneq ($(CONFIG_BLK_DEV_INITRD),y) obj-y += noinitramfs.o diff --git a/scripts/Makefile.build b/scripts/Makefile.build index 2c47f9c..9d46008 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -60,7 +60,7 @@ endif endif # Do not include host rules unless needed -ifneq ($(hostprogs-y)$(hostprogs-m),) +ifneq ($(hostprogs-y)$(hostprogs-m)$(hostlibs-y)$(hostlibs-m)$(hostcxxlibs-y)$(hostcxxlibs-m),) include scripts/Makefile.host endif diff --git a/scripts/Makefile.clean b/scripts/Makefile.clean index 55c96cb..e4e88ab 100644 --- a/scripts/Makefile.clean +++ b/scripts/Makefile.clean @@ -38,7 +38,8 @@ subdir-ymn := $(addprefix $(obj)/,$(subdir-ymn)) __clean-files := $(extra-y) $(extra-m) $(extra-) \ $(always) $(targets) $(clean-files) \ $(host-progs) \ - $(hostprogs-y) $(hostprogs-m) $(hostprogs-) + $(hostprogs-y) $(hostprogs-m) $(hostprogs-) \ + $(hostlibs-y) $(hostlibs-m) $(hostlibs-) __clean-files := $(filter-out $(no-clean-files), $(__clean-files)) diff --git a/scripts/Makefile.host b/scripts/Makefile.host index 133edfa..4d180d9 100644 --- a/scripts/Makefile.host +++ b/scripts/Makefile.host @@ -20,7 +20,25 @@ # Will compile qconf as a C++ program, and menu as a C program. # They are linked as C++ code to the executable qconf +# hostprogs-y := conf +# conf-objs := conf.o libkconfig.so +# libkconfig-objs := expr.o type.o +# Will create a shared library named libkconfig.so that consists of +# expr.o and type.o (they are both compiled as C code and the object files +# are made as position independent code). +# conf.c is compiled as a C program, and conf.o is linked together with +# libkconfig.so as the executable conf. +# Note: Shared libraries consisting of C++ files are not supported + +# hostcc-option +# Usage: cflags-y += $(call hostcc-option,-march=winchip-c6,-march=i586) + +hostcc-option = $(call try-run,\ + $(HOSTCC) $(HOSTCFLAGS) $(HOST_EXTRACFLAGS) $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2)) + __hostprogs := $(sort $(hostprogs-y) $(hostprogs-m)) +__hostlibs := $(sort $(hostlibs-y) $(hostlibs-m)) +__hostcxxlibs := $(sort $(hostcxxlibs-y) $(hostcxxlibs-m)) # C code # Executables compiled from a single .c file @@ -42,6 +60,19 @@ host-cxxmulti := $(foreach m,$(__hostprogs),$(if $($(m)-cxxobjs),$(m))) # C++ Object (.o) files compiled from .cc files host-cxxobjs := $(sort $(foreach m,$(host-cxxmulti),$($(m)-cxxobjs))) +# Shared libaries (only .c supported) +# Shared libraries (.so) - all .so files referenced in "xxx-objs" +host-cshlib := $(sort $(filter %.so, $(host-cobjs))) +host-cshlib += $(sort $(filter %.so, $(__hostlibs))) +host-cxxshlib := $(sort $(filter %.so, $(__hostcxxlibs))) +# Remove .so files from "xxx-objs" +host-cobjs := $(filter-out %.so,$(host-cobjs)) +host-cxxobjs := $(filter-out %.so,$(host-cxxobjs)) + +# Object (.o) files used by the shared libaries +host-cshobjs := $(sort $(foreach m,$(host-cshlib),$($(m:.so=-objs)))) +host-cxxshobjs := $(sort $(foreach m,$(host-cxxshlib),$($(m:.so=-objs)))) + # output directory for programs/.o files # hostprogs-y := tools/build may have been specified. # Retrieve also directory of .o files from prog-objs or prog-cxxobjs notation @@ -56,6 +87,10 @@ host-cmulti := $(addprefix $(obj)/,$(host-cmulti)) host-cobjs := $(addprefix $(obj)/,$(host-cobjs)) host-cxxmulti := $(addprefix $(obj)/,$(host-cxxmulti)) host-cxxobjs := $(addprefix $(obj)/,$(host-cxxobjs)) +host-cshlib := $(addprefix $(obj)/,$(host-cshlib)) +host-cxxshlib := $(addprefix $(obj)/,$(host-cxxshlib)) +host-cshobjs := $(addprefix $(obj)/,$(host-cshobjs)) +host-cxxshobjs := $(addprefix $(obj)/,$(host-cxxshobjs)) host-objdirs := $(addprefix $(obj)/,$(host-objdirs)) obj-dirs += $(host-objdirs) @@ -124,5 +159,37 @@ quiet_cmd_host-cxxobjs = HOSTCXX $@ $(host-cxxobjs): $(obj)/%.o: $(src)/%.cc FORCE $(call if_changed_dep,host-cxxobjs) +# Compile .c file, create position independent .o file +# host-cshobjs -> .o +quiet_cmd_host-cshobjs = HOSTCC -fPIC $@ + cmd_host-cshobjs = $(HOSTCC) $(hostc_flags) -fPIC -c -o $@ $< +$(host-cshobjs): $(obj)/%.o: $(src)/%.c FORCE + $(call if_changed_dep,host-cshobjs) + +# Compile .c file, create position independent .o file +# host-cxxshobjs -> .o +quiet_cmd_host-cxxshobjs = HOSTCXX -fPIC $@ + cmd_host-cxxshobjs = $(HOSTCXX) $(hostcxx_flags) -fPIC -c -o $@ $< +$(host-cxxshobjs): $(obj)/%.o: $(src)/%.c FORCE + $(call if_changed_dep,host-cxxshobjs) + +# Link a shared library, based on position independent .o files +# *.o -> .so shared library (host-cshlib) +quiet_cmd_host-cshlib = HOSTLLD -shared $@ + cmd_host-cshlib = $(HOSTCC) $(HOSTLDFLAGS) -shared -o $@ \ + $(addprefix $(obj)/,$($(@F:.so=-objs))) \ + $(HOST_LOADLIBES) $(HOSTLOADLIBES_$(@F)) +$(host-cshlib): $(obj)/%: $(host-cshobjs) FORCE + $(call if_changed,host-cshlib) + +# Link a shared library, based on position independent .o files +# *.o -> .so shared library (host-cxxshlib) +quiet_cmd_host-cxxshlib = HOSTLLD -shared $@ + cmd_host-cxxshlib = $(HOSTCXX) $(HOSTLDFLAGS) -shared -o $@ \ + $(addprefix $(obj)/,$($(@F:.so=-objs))) \ + $(HOST_LOADLIBES) $(HOSTLOADLIBES_$(@F)) +$(host-cxxshlib): $(obj)/%: $(host-cxxshobjs) FORCE + $(call if_changed,host-cxxshlib) + targets += $(host-csingle) $(host-cmulti) $(host-cobjs)\ - $(host-cxxmulti) $(host-cxxobjs) + $(host-cxxmulti) $(host-cxxobjs) $(host-cshlib) $(host-cshobjs) $(host-cxxshlib) $(host-cxxshobjs) diff --git a/scripts/gcc-plugin.sh b/scripts/gcc-plugin.sh new file mode 100644 index 0000000..eaa4fce --- /dev/null +++ b/scripts/gcc-plugin.sh @@ -0,0 +1,51 @@ +#!/bin/sh +srctree=$(dirname "$0") +gccplugins_dir=$($3 -print-file-name=plugin) +plugincc=$($1 -E -x c++ - -o /dev/null -I"${srctree}"/../tools/gcc -I"${gccplugins_dir}"/include 2>&1 <<EOF +#include "gcc-common.h" +#if BUILDING_GCC_VERSION >= 4008 || defined(ENABLE_BUILD_WITH_CXX) +#warning $2 CXX +#else +#warning $1 CC +#endif +EOF +) + +if [ $? -ne 0 ] +then + exit 1 +fi + +case "$plugincc" in + *"$1 CC"*) + echo "$1" + exit 0 + ;; + + *"$2 CXX"*) + # the c++ compiler needs another test, see below + ;; + + *) + exit 1 + ;; +esac + +# we need a c++ compiler that supports the designated initializer GNU extension +plugincc=$($2 -c -x c++ -std=gnu++98 - -fsyntax-only -I"${srctree}"/../tools/gcc -I"${gccplugins_dir}"/include 2>&1 <<EOF +#include "gcc-common.h" +class test { +public: + int test; +} test = { + .test = 1 +}; +EOF +) + +if [ $? -eq 0 ] +then + echo "$2" + exit 0 +fi +exit 1 diff --git a/scripts/link-vmlinux.sh b/scripts/link-vmlinux.sh index aae2473..5d62545 100755 --- a/scripts/link-vmlinux.sh +++ b/scripts/link-vmlinux.sh @@ -183,7 +183,7 @@ else fi; # final build of init/ -${MAKE} -f "${srctree}/scripts/Makefile.build" obj=init +${MAKE} -f "${srctree}/scripts/Makefile.build" obj=init GCC_PLUGINS_CFLAGS="${GCC_PLUGINS_CFLAGS}" GCC_PLUGINS_AFLAGS="${GCC_PLUGINS_AFLAGS}" kallsymso="" kallsyms_vmlinux="" diff --git a/scripts/package/builddeb b/scripts/package/builddeb index 6c3b038..54e0b5e 100755 --- a/scripts/package/builddeb +++ b/scripts/package/builddeb @@ -326,6 +326,7 @@ fi (cd $srctree; find arch/$SRCARCH -name module.lds -o -name Kbuild.platforms -o -name Platform) >> "$objtree/debian/hdrsrcfiles" (cd $srctree; find $(find arch/$SRCARCH -name include -o -name scripts -type d) -type f) >> "$objtree/debian/hdrsrcfiles" (cd $objtree; find arch/$SRCARCH/include Module.symvers include scripts -type f) >> "$objtree/debian/hdrobjfiles" +(cd $objtree; find tools/gcc -name \*.so -o -name gcc-common.h) >> "$objtree/debian/hdrobjfiles" destdir=$kernel_headers_dir/usr/src/linux-headers-$version mkdir -p "$destdir" (cd $srctree; tar -c -f - -T -) < "$objtree/debian/hdrsrcfiles" | (cd $destdir; tar -xf -) diff --git a/tools/gcc/Makefile b/tools/gcc/Makefile new file mode 100644 index 0000000..b2d64af --- /dev/null +++ b/tools/gcc/Makefile @@ -0,0 +1,15 @@ +GCC_PLUGINS_DIR := $(shell $(CC) -print-file-name=plugin) + +ifeq ($(PLUGINCC),$(HOSTCC)) +HOSTLIBS := hostlibs +HOST_EXTRACFLAGS += -I$(GCC_PLUGINS_DIR)/include -I$(src) -std=gnu99 -ggdb +export HOST_EXTRACFLAGS +else +HOSTLIBS := hostcxxlibs +HOST_EXTRACXXFLAGS += -I$(GCC_PLUGINS_DIR)/include -I$(src) -std=gnu++98 -fno-rtti -fno-exceptions -fasynchronous-unwind-tables -ggdb -Wno-narrowing -Wno-unused-variable +export HOST_EXTRACXXFLAGS +endif + +export GCCPLUGINS_DIR HOSTLIBS + +always := $($(HOSTLIBS)-y) diff --git a/tools/gcc/gcc-common.h b/tools/gcc/gcc-common.h new file mode 100644 index 0000000..355bb1a --- /dev/null +++ b/tools/gcc/gcc-common.h @@ -0,0 +1,794 @@ +#ifndef GCC_COMMON_H_INCLUDED +#define GCC_COMMON_H_INCLUDED + +#include "bversion.h" +#if BUILDING_GCC_VERSION >= 6000 +#include "gcc-plugin.h" +#else +#include "plugin.h" +#endif +#include "plugin-version.h" +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "line-map.h" +#include "input.h" +#include "tree.h" + +#include "tree-inline.h" +#include "version.h" +#include "rtl.h" +#include "tm_p.h" +#include "flags.h" +#include "hard-reg-set.h" +#include "output.h" +#include "except.h" +#include "function.h" +#include "toplev.h" +#include "basic-block.h" +#include "intl.h" +#include "ggc.h" +#include "timevar.h" + +#include "params.h" + +#if BUILDING_GCC_VERSION <= 4009 +#include "pointer-set.h" +#else +#include "hash-map.h" +#endif + +#include "emit-rtl.h" +#include "debug.h" +#include "target.h" +#include "langhooks.h" +#include "cfgloop.h" +#include "cgraph.h" +#include "opts.h" + +#if BUILDING_GCC_VERSION == 4005 +#include <sys/mman.h> +#endif + +#if BUILDING_GCC_VERSION >= 4007 +#include "tree-pretty-print.h" +#include "gimple-pretty-print.h" +#endif + +#if BUILDING_GCC_VERSION >= 4006 +#include "c-family/c-common.h" +#else +#include "c-common.h" +#endif + +#if BUILDING_GCC_VERSION <= 4008 +#include "tree-flow.h" +#else +#include "tree-cfgcleanup.h" +#include "tree-ssa-operands.h" +#include "tree-into-ssa.h" +#endif + +#if BUILDING_GCC_VERSION >= 4008 +#include "is-a.h" +#endif + +#include "diagnostic.h" +#include "tree-dump.h" +#include "tree-pass.h" +#include "predict.h" +#include "ipa-utils.h" + +#if BUILDING_GCC_VERSION >= 4009 +#include "attribs.h" +#include "varasm.h" +#include "stor-layout.h" +#include "internal-fn.h" +#include "gimple-expr.h" +#include "gimple-fold.h" +#include "context.h" +#include "tree-ssa-alias.h" +#include "tree-ssa.h" +#include "stringpool.h" +#include "tree-ssanames.h" +#include "print-tree.h" +#include "tree-eh.h" +#include "stmt.h" +#include "gimplify.h" +#endif + +#include "gimple.h" + +#if BUILDING_GCC_VERSION >= 4009 +#include "tree-ssa-operands.h" +#include "tree-phinodes.h" +#include "tree-cfg.h" +#include "gimple-iterator.h" +#include "gimple-ssa.h" +#include "ssa-iterators.h" +#endif + +#if BUILDING_GCC_VERSION >= 4007 +#else +#endif +#if BUILDING_GCC_VERSION >= 5000 +#include "builtins.h" +#endif + +//#include "expr.h" where are you... +extern rtx emit_move_insn(rtx x, rtx y); + +// missing from basic_block.h... +extern void debug_dominance_info(enum cdi_direction dir); +extern void debug_dominance_tree(enum cdi_direction dir, basic_block root); + +#if BUILDING_GCC_VERSION == 4006 +extern void debug_gimple_stmt(gimple); +extern void debug_gimple_seq(gimple_seq); +extern void print_gimple_seq(FILE *, gimple_seq, int, int); +extern void print_gimple_stmt(FILE *, gimple, int, int); +extern void print_gimple_expr(FILE *, gimple, int, int); +extern void dump_gimple_stmt(pretty_printer *, gimple, int, int); +#endif + +#ifdef __cplusplus +static inline void debug_tree(const_tree t) +{ + debug_tree(CONST_CAST_TREE(t)); +} + +static inline void debug_gimple_stmt(const_gimple s) +{ + debug_gimple_stmt(CONST_CAST_GIMPLE(s)); +} +#else +#define debug_tree(t) debug_tree(CONST_CAST_TREE(t)) +#define debug_gimple_stmt(s) debug_gimple_stmt(CONST_CAST_GIMPLE(s)) +#endif + +#define __unused __attribute__((__unused__)) + +#define DECL_NAME_POINTER(node) IDENTIFIER_POINTER(DECL_NAME(node)) +#define DECL_NAME_LENGTH(node) IDENTIFIER_LENGTH(DECL_NAME(node)) +#define TYPE_NAME_POINTER(node) IDENTIFIER_POINTER(TYPE_NAME(node)) +#define TYPE_NAME_LENGTH(node) IDENTIFIER_LENGTH(TYPE_NAME(node)) + +// should come from c-tree.h if only it were installed for gcc 4.5... +#define C_TYPE_FIELDS_READONLY(TYPE) TREE_LANG_FLAG_1(TYPE) + +#if BUILDING_GCC_VERSION == 4005 +#define FOR_EACH_LOCAL_DECL(FUN, I, D) for (tree vars = (FUN)->local_decls, (I) = 0; vars && ((D) = TREE_VALUE(vars)); vars = TREE_CHAIN(vars), (I)++) +#define DECL_CHAIN(NODE) (TREE_CHAIN(DECL_MINIMAL_CHECK(NODE))) +#define FOR_EACH_VEC_ELT(T, V, I, P) for (I = 0; VEC_iterate(T, (V), (I), (P)); ++(I)) +#define TODO_rebuild_cgraph_edges 0 +#define SCOPE_FILE_SCOPE_P(EXP) (!(EXP)) + +#ifndef O_BINARY +#define O_BINARY 0 +#endif + +typedef struct varpool_node *varpool_node_ptr; + +static inline bool gimple_call_builtin_p(gimple stmt, enum built_in_function code) +{ + tree fndecl; + + if (!is_gimple_call(stmt)) + return false; + fndecl = gimple_call_fndecl(stmt); + if (!fndecl || DECL_BUILT_IN_CLASS(fndecl) != BUILT_IN_NORMAL) + return false; + return DECL_FUNCTION_CODE(fndecl) == code; +} + +static inline bool is_simple_builtin(tree decl) +{ + if (decl && DECL_BUILT_IN_CLASS(decl) != BUILT_IN_NORMAL) + return false; + + switch (DECL_FUNCTION_CODE(decl)) { + /* Builtins that expand to constants. */ + case BUILT_IN_CONSTANT_P: + case BUILT_IN_EXPECT: + case BUILT_IN_OBJECT_SIZE: + case BUILT_IN_UNREACHABLE: + /* Simple register moves or loads from stack. */ + case BUILT_IN_RETURN_ADDRESS: + case BUILT_IN_EXTRACT_RETURN_ADDR: + case BUILT_IN_FROB_RETURN_ADDR: + case BUILT_IN_RETURN: + case BUILT_IN_AGGREGATE_INCOMING_ADDRESS: + case BUILT_IN_FRAME_ADDRESS: + case BUILT_IN_VA_END: + case BUILT_IN_STACK_SAVE: + case BUILT_IN_STACK_RESTORE: + /* Exception state returns or moves registers around. */ + case BUILT_IN_EH_FILTER: + case BUILT_IN_EH_POINTER: + case BUILT_IN_EH_COPY_VALUES: + return true; + + default: + return false; + } +} + +static inline void add_local_decl(struct function *fun, tree d) +{ + gcc_assert(TREE_CODE(d) == VAR_DECL); + fun->local_decls = tree_cons(NULL_TREE, d, fun->local_decls); +} +#endif + +#if BUILDING_GCC_VERSION <= 4006 +#define ANY_RETURN_P(rtx) (GET_CODE(rtx) == RETURN) +#define C_DECL_REGISTER(EXP) DECL_LANG_FLAG_4(EXP) +#define EDGE_PRESERVE 0ULL +#define HOST_WIDE_INT_PRINT_HEX_PURE "%" HOST_WIDE_INT_PRINT "x" +#define flag_fat_lto_objects true + +#define get_random_seed(noinit) ({ \ + unsigned HOST_WIDE_INT seed; \ + sscanf(get_random_seed(noinit), "%" HOST_WIDE_INT_PRINT "x", &seed); \ + seed * seed; }) + +#define int_const_binop(code, arg1, arg2) int_const_binop((code), (arg1), (arg2), 0) + +static inline bool gimple_clobber_p(gimple s __unused) +{ + return false; +} + +static inline bool gimple_asm_clobbers_memory_p(const_gimple stmt) +{ + unsigned i; + + for (i = 0; i < gimple_asm_nclobbers(stmt); i++) { + tree op = gimple_asm_clobber_op(stmt, i); + if (!strcmp(TREE_STRING_POINTER(TREE_VALUE(op)), "memory")) + return true; + } + + return false; +} + +static inline tree builtin_decl_implicit(enum built_in_function fncode) +{ + return implicit_built_in_decls[fncode]; +} + +static inline int ipa_reverse_postorder(struct cgraph_node **order) +{ + return cgraph_postorder(order); +} + +static inline struct cgraph_node *cgraph_get_create_node(tree decl) +{ + struct cgraph_node *node = cgraph_get_node(decl); + + return node ? node : cgraph_node(decl); +} + +static inline bool cgraph_function_with_gimple_body_p(struct cgraph_node *node) +{ + return node->analyzed && !node->thunk.thunk_p && !node->alias; +} + +static inline struct cgraph_node *cgraph_first_function_with_gimple_body(void) +{ + struct cgraph_node *node; + + for (node = cgraph_nodes; node; node = node->next) + if (cgraph_function_with_gimple_body_p(node)) + return node; + return NULL; +} + +static inline struct cgraph_node *cgraph_next_function_with_gimple_body(struct cgraph_node *node) +{ + for (node = node->next; node; node = node->next) + if (cgraph_function_with_gimple_body_p(node)) + return node; + return NULL; +} + +#define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \ + for ((node) = cgraph_first_function_with_gimple_body(); (node); \ + (node) = cgraph_next_function_with_gimple_body(node)) + +static inline void varpool_add_new_variable(tree decl) +{ + varpool_finalize_decl(decl); +} +#endif + +#if BUILDING_GCC_VERSION <= 4007 +#define FOR_EACH_FUNCTION(node) for (node = cgraph_nodes; node; node = node->next) +#define FOR_EACH_VARIABLE(node) for (node = varpool_nodes; node; node = node->next) +#define PROP_loops 0 +#define NODE_SYMBOL(node) (node) +#define NODE_DECL(node) (node)->decl +#define INSN_LOCATION(INSN) RTL_LOCATION(INSN) + +static inline int bb_loop_depth(const_basic_block bb) +{ + return bb->loop_father ? loop_depth(bb->loop_father) : 0; +} + +static inline bool gimple_store_p(gimple gs) +{ + tree lhs = gimple_get_lhs(gs); + return lhs && !is_gimple_reg(lhs); +} +#endif + +#if BUILDING_GCC_VERSION == 4007 || BUILDING_GCC_VERSION == 4008 +static inline struct cgraph_node *cgraph_alias_target(struct cgraph_node *n) +{ + return cgraph_alias_aliased_node(n); +} +#endif + +#if BUILDING_GCC_VERSION >= 4007 && BUILDING_GCC_VERSION <= 4009 +#define cgraph_create_edge(caller, callee, call_stmt, count, freq, nest) \ + cgraph_create_edge((caller), (callee), (call_stmt), (count), (freq)) +#define cgraph_create_edge_including_clones(caller, callee, old_call_stmt, call_stmt, count, freq, nest, reason) \ + cgraph_create_edge_including_clones((caller), (callee), (old_call_stmt), (call_stmt), (count), (freq), (reason)) +#endif + +#if BUILDING_GCC_VERSION <= 4008 +#define ENTRY_BLOCK_PTR_FOR_FN(FN) ENTRY_BLOCK_PTR_FOR_FUNCTION(FN) +#define EXIT_BLOCK_PTR_FOR_FN(FN) EXIT_BLOCK_PTR_FOR_FUNCTION(FN) +#define basic_block_info_for_fn(FN) ((FN)->cfg->x_basic_block_info) +#define n_basic_blocks_for_fn(FN) ((FN)->cfg->x_n_basic_blocks) +#define n_edges_for_fn(FN) ((FN)->cfg->x_n_edges) +#define last_basic_block_for_fn(FN) ((FN)->cfg->x_last_basic_block) +#define label_to_block_map_for_fn(FN) ((FN)->cfg->x_label_to_block_map) +#define profile_status_for_fn(FN) ((FN)->cfg->x_profile_status) +#define BASIC_BLOCK_FOR_FN(FN, N) BASIC_BLOCK_FOR_FUNCTION((FN), (N)) +#define NODE_IMPLICIT_ALIAS(node) (node)->same_body_alias +#define VAR_P(NODE) (TREE_CODE(NODE) == VAR_DECL) + +static inline bool tree_fits_shwi_p(const_tree t) +{ + if (t == NULL_TREE || TREE_CODE(t) != INTEGER_CST) + return false; + + if (TREE_INT_CST_HIGH(t) == 0 && (HOST_WIDE_INT)TREE_INT_CST_LOW(t) >= 0) + return true; + + if (TREE_INT_CST_HIGH(t) == -1 && (HOST_WIDE_INT)TREE_INT_CST_LOW(t) < 0 && !TYPE_UNSIGNED(TREE_TYPE(t))) + return true; + + return false; +} + +static inline bool tree_fits_uhwi_p(const_tree t) +{ + if (t == NULL_TREE || TREE_CODE(t) != INTEGER_CST) + return false; + + return TREE_INT_CST_HIGH(t) == 0; +} + +static inline HOST_WIDE_INT tree_to_shwi(const_tree t) +{ + gcc_assert(tree_fits_shwi_p(t)); + return TREE_INT_CST_LOW(t); +} + +static inline unsigned HOST_WIDE_INT tree_to_uhwi(const_tree t) +{ + gcc_assert(tree_fits_uhwi_p(t)); + return TREE_INT_CST_LOW(t); +} + +static inline const char *get_tree_code_name(enum tree_code code) +{ + gcc_assert(code < MAX_TREE_CODES); + return tree_code_name[code]; +} + +#define ipa_remove_stmt_references(cnode, stmt) + +typedef union gimple_statement_d gasm; +typedef union gimple_statement_d gassign; +typedef union gimple_statement_d gcall; +typedef union gimple_statement_d gcond; +typedef union gimple_statement_d gdebug; +typedef union gimple_statement_d gphi; +typedef union gimple_statement_d greturn; + +static inline gasm *as_a_gasm(gimple stmt) +{ + return stmt; +} + +static inline const gasm *as_a_const_gasm(const_gimple stmt) +{ + return stmt; +} + +static inline gassign *as_a_gassign(gimple stmt) +{ + return stmt; +} + +static inline const gassign *as_a_const_gassign(const_gimple stmt) +{ + return stmt; +} + +static inline gcall *as_a_gcall(gimple stmt) +{ + return stmt; +} + +static inline const gcall *as_a_const_gcall(const_gimple stmt) +{ + return stmt; +} + +static inline gcond *as_a_gcond(gimple stmt) +{ + return stmt; +} + +static inline const gcond *as_a_const_gcond(const_gimple stmt) +{ + return stmt; +} + +static inline gdebug *as_a_gdebug(gimple stmt) +{ + return stmt; +} + +static inline const gdebug *as_a_const_gdebug(const_gimple stmt) +{ + return stmt; +} + +static inline gphi *as_a_gphi(gimple stmt) +{ + return stmt; +} + +static inline const gphi *as_a_const_gphi(const_gimple stmt) +{ + return stmt; +} + +static inline greturn *as_a_greturn(gimple stmt) +{ + return stmt; +} + +static inline const greturn *as_a_const_greturn(const_gimple stmt) +{ + return stmt; +} +#endif + +#if BUILDING_GCC_VERSION == 4008 +#define NODE_SYMBOL(node) (&(node)->symbol) +#define NODE_DECL(node) (node)->symbol.decl +#endif + +#if BUILDING_GCC_VERSION >= 4008 +#define add_referenced_var(var) +#define mark_sym_for_renaming(var) +#define varpool_mark_needed_node(node) +#define create_var_ann(var) +#define TODO_dump_func 0 +#define TODO_dump_cgraph 0 +#endif + +#if BUILDING_GCC_VERSION <= 4009 +#define TODO_verify_il 0 +#define AVAIL_INTERPOSABLE AVAIL_OVERWRITABLE + +#define section_name_prefix LTO_SECTION_NAME_PREFIX +#define fatal_error(loc, gmsgid, ...) fatal_error((gmsgid), __VA_ARGS__) + +typedef struct rtx_def rtx_insn; + +static inline void set_decl_section_name(tree node, const char *value) +{ + DECL_SECTION_NAME(node) = build_string(strlen(value) + 1, value); +} +#endif + +#if BUILDING_GCC_VERSION == 4009 +typedef struct gimple_statement_asm gasm; +typedef struct gimple_statement_base gassign; +typedef struct gimple_statement_call gcall; +typedef struct gimple_statement_base gcond; +typedef struct gimple_statement_base gdebug; +typedef struct gimple_statement_phi gphi; +typedef struct gimple_statement_base greturn; + +static inline gasm *as_a_gasm(gimple stmt) +{ + return as_a<gasm>(stmt); +} + +static inline const gasm *as_a_const_gasm(const_gimple stmt) +{ + return as_a<const gasm>(stmt); +} + +static inline gassign *as_a_gassign(gimple stmt) +{ + return stmt; +} + +static inline const gassign *as_a_const_gassign(const_gimple stmt) +{ + return stmt; +} + +static inline gcall *as_a_gcall(gimple stmt) +{ + return as_a<gcall>(stmt); +} + +static inline const gcall *as_a_const_gcall(const_gimple stmt) +{ + return as_a<const gcall>(stmt); +} + +static inline gcond *as_a_gcond(gimple stmt) +{ + return stmt; +} + +static inline const gcond *as_a_const_gcond(const_gimple stmt) +{ + return stmt; +} + +static inline gdebug *as_a_gdebug(gimple stmt) +{ + return stmt; +} + +static inline const gdebug *as_a_const_gdebug(const_gimple stmt) +{ + return stmt; +} + +static inline gphi *as_a_gphi(gimple stmt) +{ + return as_a<gphi>(stmt); +} + +static inline const gphi *as_a_const_gphi(const_gimple stmt) +{ + return as_a<const gphi>(stmt); +} + +static inline greturn *as_a_greturn(gimple stmt) +{ + return stmt; +} + +static inline const greturn *as_a_const_greturn(const_gimple stmt) +{ + return stmt; +} +#endif + +#if BUILDING_GCC_VERSION >= 4009 +#define TODO_ggc_collect 0 +#define NODE_SYMBOL(node) (node) +#define NODE_DECL(node) (node)->decl +#define cgraph_node_name(node) (node)->name() +#define NODE_IMPLICIT_ALIAS(node) (node)->cpp_implicit_alias +#endif + +#if BUILDING_GCC_VERSION >= 5000 && BUILDING_GCC_VERSION < 6000 +// gimple related +template <> +template <> +inline bool is_a_helper<const gassign *>::test(const_gimple gs) +{ + return gs->code == GIMPLE_ASSIGN; +} +#endif + +#if BUILDING_GCC_VERSION >= 5000 +#define TODO_verify_ssa TODO_verify_il +#define TODO_verify_flow TODO_verify_il +#define TODO_verify_stmts TODO_verify_il +#define TODO_verify_rtl_sharing TODO_verify_il + +#define INSN_DELETED_P(insn) (insn)->deleted() + +// symtab/cgraph related +#define debug_cgraph_node(node) (node)->debug() +#define cgraph_get_node(decl) cgraph_node::get(decl) +#define cgraph_get_create_node(decl) cgraph_node::get_create(decl) +#define cgraph_n_nodes symtab->cgraph_count +#define cgraph_max_uid symtab->cgraph_max_uid +#define varpool_get_node(decl) varpool_node::get(decl) + +#define cgraph_create_edge(caller, callee, call_stmt, count, freq, nest) \ + (caller)->create_edge((callee), (call_stmt), (count), (freq)) +#define cgraph_create_edge_including_clones(caller, callee, old_call_stmt, call_stmt, count, freq, nest, reason) \ + (caller)->create_edge_including_clones((callee), (old_call_stmt), (call_stmt), (count), (freq), (reason)) + +typedef struct cgraph_node *cgraph_node_ptr; +typedef struct cgraph_edge *cgraph_edge_p; +typedef struct varpool_node *varpool_node_ptr; + +static inline void change_decl_assembler_name(tree decl, tree name) +{ + symtab->change_decl_assembler_name(decl, name); +} + +static inline void varpool_finalize_decl(tree decl) +{ + varpool_node::finalize_decl(decl); +} + +static inline void varpool_add_new_variable(tree decl) +{ + varpool_node::add(decl); +} + +static inline unsigned int rebuild_cgraph_edges(void) +{ + return cgraph_edge::rebuild_edges(); +} + +static inline cgraph_node_ptr cgraph_function_node(cgraph_node_ptr node, enum availability *availability) +{ + return node->function_symbol(availability); +} + +static inline cgraph_node_ptr cgraph_function_or_thunk_node(cgraph_node_ptr node, enum availability *availability = NULL) +{ + return node->ultimate_alias_target(availability); +} + +static inline bool cgraph_only_called_directly_p(cgraph_node_ptr node) +{ + return node->only_called_directly_p(); +} + +static inline enum availability cgraph_function_body_availability(cgraph_node_ptr node) +{ + return node->get_availability(); +} + +static inline cgraph_node_ptr cgraph_alias_target(cgraph_node_ptr node) +{ + return node->get_alias_target(); +} + +static inline struct cgraph_node_hook_list *cgraph_add_function_insertion_hook(cgraph_node_hook hook, void *data) +{ + return symtab->add_cgraph_insertion_hook(hook, data); +} + +static inline void cgraph_remove_function_insertion_hook(struct cgraph_node_hook_list *entry) +{ + symtab->remove_cgraph_insertion_hook(entry); +} + +static inline struct cgraph_node_hook_list *cgraph_add_node_removal_hook(cgraph_node_hook hook, void *data) +{ + return symtab->add_cgraph_removal_hook(hook, data); +} + +static inline void cgraph_remove_node_removal_hook(struct cgraph_node_hook_list *entry) +{ + symtab->remove_cgraph_removal_hook(entry); +} + +static inline struct cgraph_2node_hook_list *cgraph_add_node_duplication_hook(cgraph_2node_hook hook, void *data) +{ + return symtab->add_cgraph_duplication_hook(hook, data); +} + +static inline void cgraph_remove_node_duplication_hook(struct cgraph_2node_hook_list *entry) +{ + symtab->remove_cgraph_duplication_hook(entry); +} + +#if BUILDING_GCC_VERSION >= 6000 +typedef gimple *gimple_ptr; +typedef const gimple *const_gimple; +#define gimple gimple_ptr +#endif + +// gimple related +static inline gimple gimple_build_assign_with_ops(enum tree_code subcode, tree lhs, tree op1, tree op2 MEM_STAT_DECL) +{ + return gimple_build_assign(lhs, subcode, op1, op2 PASS_MEM_STAT); +} + +template <> +template <> +inline bool is_a_helper<const greturn *>::test(const_gimple gs) +{ + return gs->code == GIMPLE_RETURN; +} + +static inline gasm *as_a_gasm(gimple stmt) +{ + return as_a<gasm *>(stmt); +} + +static inline const gasm *as_a_const_gasm(const_gimple stmt) +{ + return as_a<const gasm *>(stmt); +} + +static inline gassign *as_a_gassign(gimple stmt) +{ + return as_a<gassign *>(stmt); +} + +static inline const gassign *as_a_const_gassign(const_gimple stmt) +{ + return as_a<const gassign *>(stmt); +} + +static inline gcall *as_a_gcall(gimple stmt) +{ + return as_a<gcall *>(stmt); +} + +static inline const gcall *as_a_const_gcall(const_gimple stmt) +{ + return as_a<const gcall *>(stmt); +} + +static inline gphi *as_a_gphi(gimple stmt) +{ + return as_a<gphi *>(stmt); +} + +static inline const gphi *as_a_const_gphi(const_gimple stmt) +{ + return as_a<const gphi *>(stmt); +} + +static inline greturn *as_a_greturn(gimple stmt) +{ + return as_a<greturn *>(stmt); +} + +static inline const greturn *as_a_const_greturn(const_gimple stmt) +{ + return as_a<const greturn *>(stmt); +} + +// IPA/LTO related +#define ipa_ref_list_referring_iterate(L,I,P) (L)->referring.iterate((I), &(P)) +#define ipa_ref_list_reference_iterate(L,I,P) (L)->reference.iterate((I), &(P)) + +static inline cgraph_node_ptr ipa_ref_referring_node(struct ipa_ref *ref) +{ + return dyn_cast<cgraph_node_ptr>(ref->referring); +} + +static inline void ipa_remove_stmt_references(symtab_node *referring_node, gimple stmt) +{ + referring_node->remove_stmt_references(stmt); +} +#endif + +#if BUILDING_GCC_VERSION < 6000 +#define get_inner_reference(exp, pbitsize, pbitpos, poffset, pmode, punsignedp, preversep, pvolatilep, keep_aligning) get_inner_reference(exp, pbitsize, pbitpos, poffset, pmode, punsignedp, pvolatilep, keep_aligning) +#define gen_rtx_set(ARG0, ARG1) gen_rtx_SET(VOIDmode, (ARG0), (ARG1)) +#endif + +#if BUILDING_GCC_VERSION >= 6000 +#define gen_rtx_set(ARG0, ARG1) gen_rtx_SET((ARG0), (ARG1)) +#endif + +#endif ^ permalink raw reply related [flat|nested] 13+ messages in thread
* [kernel-hardening] Re: [PATCH 1/3] GCC plugin infrastructure 2016-02-07 21:28 ` [kernel-hardening] [PATCH 1/3] " Emese Revfy @ 2016-02-08 20:28 ` Michal Marek 2016-02-08 21:31 ` Emese Revfy 0 siblings, 1 reply; 13+ messages in thread From: Michal Marek @ 2016-02-08 20:28 UTC (permalink / raw) To: Emese Revfy; +Cc: linux-kbuild, pageexec, spender, kernel-hardening, keescook Dne 7.2.2016 v 22:28 Emese Revfy napsal(a): > This patch allows to build the whole kernel with GCC plugins. It was ported from > grsecurity/PaX. The infrastructure supports building out-of-tree modules and > building in a separate directory. Cross-compilation is supported too but > currently only the x86 architecture enables plugins. > > The directory of the gcc plugins is tools/gcc. You can use a file or a directory > there. The plugins compile with these options: > * -fno-rtti: gcc is compiled with this option so the plugins must use it too > * -fno-exceptions: this is inherited from gcc too > * -fasynchronous-unwind-tables: this is inherited from gcc too > * -ggdb: it is useful for debugging a plugin (better backtrace on internal > errors) > * -Wno-narrowing: to suppress warnings from gcc headers (ipa-utils.h) > * -Wno-unused-variable: to suppress warnings from gcc headers (gcc_version > variable, plugin-version.h) > > The infrastructure introduces a new Makefile target called gcc-plugins. It > supports all gcc versions from 4.5 to 6.0. The scripts/gcc-plugin.sh script > chooses the proper host compiler (gcc-4.7 can be built by either gcc or g++). > This script also checks the availability of the included headers in > tools/gcc/gcc-common.h. > > The gcc-common.h header contains frequently included headers for GCC plugins > and it has a compatibility layer for the supported gcc versions. The changelog is missing an explanation as to why this needs to be part of the kernel build system. To me it looks like building the kernel with a modified build system and non-default compiler flags, which can be achieved by doing make CC=my-gcc-wrapper or somesuch. But I'd love to be corrected. Michal ^ permalink raw reply [flat|nested] 13+ messages in thread
* [kernel-hardening] Re: [PATCH 1/3] GCC plugin infrastructure 2016-02-08 20:28 ` [kernel-hardening] " Michal Marek @ 2016-02-08 21:31 ` Emese Revfy 0 siblings, 0 replies; 13+ messages in thread From: Emese Revfy @ 2016-02-08 21:31 UTC (permalink / raw) To: Michal Marek; +Cc: linux-kbuild, pageexec, spender, kernel-hardening, keescook On Mon, 8 Feb 2016 21:28:13 +0100 Michal Marek <mmarek@suse.com> wrote: > Dne 7.2.2016 v 22:28 Emese Revfy napsal(a): > > This patch allows to build the whole kernel with GCC plugins. It was ported from > > grsecurity/PaX. The infrastructure supports building out-of-tree modules and > > building in a separate directory. Cross-compilation is supported too but > > currently only the x86 architecture enables plugins. > > > > The directory of the gcc plugins is tools/gcc. You can use a file or a directory > > there. The plugins compile with these options: > > * -fno-rtti: gcc is compiled with this option so the plugins must use it too > > * -fno-exceptions: this is inherited from gcc too > > * -fasynchronous-unwind-tables: this is inherited from gcc too > > * -ggdb: it is useful for debugging a plugin (better backtrace on internal > > errors) > > * -Wno-narrowing: to suppress warnings from gcc headers (ipa-utils.h) > > * -Wno-unused-variable: to suppress warnings from gcc headers (gcc_version > > variable, plugin-version.h) > > > > The infrastructure introduces a new Makefile target called gcc-plugins. It > > supports all gcc versions from 4.5 to 6.0. The scripts/gcc-plugin.sh script > > chooses the proper host compiler (gcc-4.7 can be built by either gcc or g++). > > This script also checks the availability of the included headers in > > tools/gcc/gcc-common.h. > > > > The gcc-common.h header contains frequently included headers for GCC plugins > > and it has a compatibility layer for the supported gcc versions. > > The changelog is missing an explanation as to why this needs to be part > of the kernel build system. To me it looks like building the kernel with > a modified build system and non-default compiler flags, which can be > achieved by doing make CC=my-gcc-wrapper or somesuch. But I'd love to be > corrected. These compiler options compile the gcc plugins not the kernel. The new gcc option used for building the kernel is the -fplugin option. -- Emese ^ permalink raw reply [flat|nested] 13+ messages in thread
* [kernel-hardening] [PATCH 2/3] Add Cyclomatic complexity GCC plugin 2016-02-07 21:27 [kernel-hardening] [PATCH 0/3] Introduce GCC plugin infrastructure Emese Revfy 2016-02-07 21:28 ` [kernel-hardening] [PATCH 1/3] " Emese Revfy @ 2016-02-07 21:31 ` Emese Revfy 2016-02-07 23:05 ` [kernel-hardening] " Rasmus Villemoes 2016-02-09 4:23 ` Kees Cook 2016-02-07 21:32 ` [kernel-hardening] [PATCH 3/3] Documentation for the GCC plugin infrastructure Emese Revfy 2 siblings, 2 replies; 13+ messages in thread From: Emese Revfy @ 2016-02-07 21:31 UTC (permalink / raw) To: linux-kbuild; +Cc: pageexec, spender, kernel-hardening, mmarek, keescook Add a very simple plugin to demonstrate the GCC plugin infrastructure. This GCC plugin computes the cyclomatic complexity of each function. The complexity M of a function's control flow graph is defined as: M = E - N + 2P where E = the number of edges N = the number of nodes P = the number of connected components (exit nodes). --- Makefile | 6 +- arch/Kconfig | 16 +++++ tools/gcc/Makefile | 4 ++ tools/gcc/cyc_complexity_plugin.c | 120 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 145 insertions(+), 1 deletion(-) create mode 100644 tools/gcc/cyc_complexity_plugin.c diff --git a/Makefile b/Makefile index 96ce015..9f76c26 100644 --- a/Makefile +++ b/Makefile @@ -628,7 +628,11 @@ else PLUGINCC := $(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-plugin.sh "$(HOSTCC)" "$(HOSTCXX)" "$(CC)") endif ifneq ($(PLUGINCC),) -export PLUGINCC GCC_PLUGINS_CFLAGS GCC_PLUGINS_AFLAGS +ifdef CONFIG_GCC_PLUGIN_CYC_COMPLEXITY +GCC_PLUGIN_CYC_COMPLEXITY_CFLAGS := -fplugin=$(objtree)/tools/gcc/cyc_complexity_plugin.so -DGCC_PLUGIN_CYC_COMPLEXITY +endif +GCC_PLUGINS_CFLAGS := $(GCC_PLUGIN_CYC_COMPLEXITY_CFLAGS) +export PLUGINCC GCC_PLUGINS_CFLAGS GCC_PLUGINS_AFLAGS GCC_PLUGIN_CYC_COMPLEXITY ifeq ($(KBUILD_EXTMOD),) gcc-plugins: $(Q)$(MAKE) $(build)=tools/gcc diff --git a/arch/Kconfig b/arch/Kconfig index a95e5b1..6b7d4de 100644 --- a/arch/Kconfig +++ b/arch/Kconfig @@ -365,6 +365,22 @@ config HAVE_GCC_PLUGINS An arch should select this symbol if it supports building with gcc plugins. +if HAVE_GCC_PLUGINS + +config GCC_PLUGIN_CYC_COMPLEXITY + bool "Compute the cyclomatic complexity of a function" + help + The complexity M of a function's control flow graph is defined as: + M = E - N + 2P + where + + E = the number of edges + N = the number of nodes + P = the number of connected components (exit nodes). + + See Documentation/gcc-plugins.txt for details. + +endif # HAVE_GCC_PLUGINS endmenu # "GCC plugins" config HAVE_CC_STACKPROTECTOR diff --git a/tools/gcc/Makefile b/tools/gcc/Makefile index b2d64af..31c72bf 100644 --- a/tools/gcc/Makefile +++ b/tools/gcc/Makefile @@ -12,4 +12,8 @@ endif export GCCPLUGINS_DIR HOSTLIBS +$(HOSTLIBS)-$(CONFIG_GCC_PLUGIN_CYC_COMPLEXITY) := cyc_complexity_plugin.so + always := $($(HOSTLIBS)-y) + +cyc_complexity_plugin-objs := cyc_complexity_plugin.o diff --git a/tools/gcc/cyc_complexity_plugin.c b/tools/gcc/cyc_complexity_plugin.c new file mode 100644 index 0000000..c6f0d58 --- /dev/null +++ b/tools/gcc/cyc_complexity_plugin.c @@ -0,0 +1,120 @@ +/* + * Copyright 2011-2016 by Emese Revfy <re.emese@gmail.com> + * Licensed under the GPL v2, or (at your option) v3 + * + * Homepage: + * https://github.com/ephox-gcc-plugins/cyclomatic_complexity + * + * http://en.wikipedia.org/wiki/Cyclomatic_complexity + * The complexity M is then defined as: + * M = E - N + 2P + * where + * + * E = the number of edges of the graph + * N = the number of nodes of the graph + * P = the number of connected components (exit nodes). + * + * Usage (4.5 - 5): + * $ make clean; make run + */ + +#include "gcc-common.h" + +int plugin_is_GPL_compatible; + +static struct plugin_info cyc_complexity_plugin_info = { + .version = "20150523", + .help = "Cyclomatic Complexity\n", +}; + +static unsigned int handle_function(void) +{ + int complexity; + expanded_location xloc; + + // M = E - N + 2P + complexity = n_edges_for_fn(cfun) - n_basic_blocks_for_fn(cfun) + 2; + + xloc = expand_location(DECL_SOURCE_LOCATION(current_function_decl)); + fprintf(stderr, "Cyclomatic Complexity %d %s:%s\n", complexity, xloc.file, DECL_NAME_POINTER(current_function_decl)); + + return 0; +} + +#if BUILDING_GCC_VERSION >= 4009 +namespace { +static const struct pass_data cyc_complexity_pass_data = { +#else +static struct gimple_opt_pass cyc_complexity_pass = { + .pass = { +#endif + .type = GIMPLE_PASS, + .name = "cyc_complexity", +#if BUILDING_GCC_VERSION >= 4008 + .optinfo_flags = OPTGROUP_NONE, +#endif +#if BUILDING_GCC_VERSION >= 5000 +#elif BUILDING_GCC_VERSION >= 4009 + .has_gate = false, + .has_execute = true, +#else + .gate = NULL, + .execute = handle_function, + .sub = NULL, + .next = NULL, + .static_pass_number = 0, +#endif + .tv_id = TV_NONE, + .properties_required = 0, + .properties_provided = 0, + .properties_destroyed = 0, + .todo_flags_start = 0, + .todo_flags_finish = TODO_dump_func +#if BUILDING_GCC_VERSION < 4009 + } +#endif +}; + +#if BUILDING_GCC_VERSION >= 4009 +class cyc_complexity_pass : public gimple_opt_pass { +public: + cyc_complexity_pass() : gimple_opt_pass(cyc_complexity_pass_data, g) {} +#if BUILDING_GCC_VERSION >= 5000 + virtual unsigned int execute(function *) { return handle_function(); } +#else + unsigned int execute() { return handle_function(); } +#endif +}; +} + +static struct opt_pass *make_cyc_complexity_pass(void) +{ + return new cyc_complexity_pass(); +} +#else +static struct opt_pass *make_cyc_complexity_pass(void) +{ + return &cyc_complexity_pass.pass; +} +#endif + +int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gcc_version *version) +{ + const char * const plugin_name = plugin_info->base_name; + struct register_pass_info cyc_complexity_pass_info; + + cyc_complexity_pass_info.pass = make_cyc_complexity_pass(); + cyc_complexity_pass_info.reference_pass_name = "ssa"; + cyc_complexity_pass_info.ref_pass_instance_number = 1; + cyc_complexity_pass_info.pos_op = PASS_POS_INSERT_AFTER; + + if (!plugin_default_version_check(version, &gcc_version)) { + error(G_("incompatible gcc/plugin versions")); + return 1; + } + + register_callback(plugin_name, PLUGIN_INFO, NULL, &cyc_complexity_plugin_info); + register_callback(plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &cyc_complexity_pass_info); + + return 0; +} ^ permalink raw reply related [flat|nested] 13+ messages in thread
* [kernel-hardening] Re: [PATCH 2/3] Add Cyclomatic complexity GCC plugin 2016-02-07 21:31 ` [kernel-hardening] [PATCH 2/3] Add Cyclomatic complexity GCC plugin Emese Revfy @ 2016-02-07 23:05 ` Rasmus Villemoes 2016-02-08 21:20 ` Emese Revfy 2016-02-09 4:23 ` Kees Cook 1 sibling, 1 reply; 13+ messages in thread From: Rasmus Villemoes @ 2016-02-07 23:05 UTC (permalink / raw) To: Emese Revfy Cc: linux-kbuild, pageexec, spender, kernel-hardening, mmarek, keescook On Sun, Feb 07 2016, Emese Revfy <re.emese@gmail.com> wrote: > Add a very simple plugin to demonstrate the GCC plugin infrastructure. > This GCC plugin computes the cyclomatic complexity of each function. > > The complexity M of a function's control flow graph is defined as: > M = E - N + 2P > where > E = the number of edges > N = the number of nodes > P = the number of connected components (exit nodes). > > --- > Makefile | 6 +- > arch/Kconfig | 16 +++++ > tools/gcc/Makefile | 4 ++ > tools/gcc/cyc_complexity_plugin.c | 120 ++++++++++++++++++++++++++++++++++++++ > 4 files changed, 145 insertions(+), 1 deletion(-) > create mode 100644 tools/gcc/cyc_complexity_plugin.c > > diff --git a/Makefile b/Makefile > index 96ce015..9f76c26 100644 > --- a/Makefile > +++ b/Makefile > @@ -628,7 +628,11 @@ else > PLUGINCC := $(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-plugin.sh "$(HOSTCC)" "$(HOSTCXX)" "$(CC)") > endif > ifneq ($(PLUGINCC),) > -export PLUGINCC GCC_PLUGINS_CFLAGS GCC_PLUGINS_AFLAGS > +ifdef CONFIG_GCC_PLUGIN_CYC_COMPLEXITY > +GCC_PLUGIN_CYC_COMPLEXITY_CFLAGS := -fplugin=$(objtree)/tools/gcc/cyc_complexity_plugin.so -DGCC_PLUGIN_CYC_COMPLEXITY > +endif > +GCC_PLUGINS_CFLAGS := $(GCC_PLUGIN_CYC_COMPLEXITY_CFLAGS) > +export PLUGINCC GCC_PLUGINS_CFLAGS GCC_PLUGINS_AFLAGS GCC_PLUGIN_CYC_COMPLEXITY Hm, when the number of plugins grow, I think it'll be somewhat ugly having all this in the main makefile. Can't all the plugin-related stuff live in a separate makefile? The same goes for the Kconfig part. Also, I think the compile command lines are already complicated enough (I sometimes use V=1 to see what's going on), so I think it's better that the plugins that need to make themselves known do so "from within" gcc; something like static void define_feature_macro(void __unused *event_data, void __unused *data) { cpp_define(parse_in, "HAVE_ATTRIBUTE_FOOBAR"); } ... register_callback(plugin_name, PLUGIN_START_UNIT, &define_feature_macro, NULL); > + > +#include "gcc-common.h" > + > +int plugin_is_GPL_compatible; > + > +static struct plugin_info cyc_complexity_plugin_info = { > + .version = "20150523", > + .help = "Cyclomatic Complexity\n", > +}; > + > +static unsigned int handle_function(void) > +{ > + int complexity; > + expanded_location xloc; > + > + // M = E - N + 2P > + complexity = n_edges_for_fn(cfun) - n_basic_blocks_for_fn(cfun) + 2; > + > + xloc = expand_location(DECL_SOURCE_LOCATION(current_function_decl)); > + fprintf(stderr, "Cyclomatic Complexity %d %s:%s\n", complexity, xloc.file, DECL_NAME_POINTER(current_function_decl)); > + > + return 0; > +} > + > +#if BUILDING_GCC_VERSION >= 4009 > +namespace { > +static const struct pass_data cyc_complexity_pass_data = { > +#else > +static struct gimple_opt_pass cyc_complexity_pass = { > + .pass = { > +#endif > + .type = GIMPLE_PASS, > + .name = "cyc_complexity", > +#if BUILDING_GCC_VERSION >= 4008 > + .optinfo_flags = OPTGROUP_NONE, > +#endif > +#if BUILDING_GCC_VERSION >= 5000 > +#elif BUILDING_GCC_VERSION >= 4009 > + .has_gate = false, > + .has_execute = true, > +#else > + .gate = NULL, > + .execute = handle_function, > + .sub = NULL, > + .next = NULL, > + .static_pass_number = 0, > +#endif > + .tv_id = TV_NONE, > + .properties_required = 0, > + .properties_provided = 0, > + .properties_destroyed = 0, > + .todo_flags_start = 0, > + .todo_flags_finish = TODO_dump_func > +#if BUILDING_GCC_VERSION < 4009 > + } > +#endif > +}; > + This is really yucky. Is there any way a mere mortal could figure out how to write this? Or could the compatibility layer provide some utility macros that would take care of the boilerplate? Rasmus ^ permalink raw reply [flat|nested] 13+ messages in thread
* [kernel-hardening] Re: [PATCH 2/3] Add Cyclomatic complexity GCC plugin 2016-02-07 23:05 ` [kernel-hardening] " Rasmus Villemoes @ 2016-02-08 21:20 ` Emese Revfy 0 siblings, 0 replies; 13+ messages in thread From: Emese Revfy @ 2016-02-08 21:20 UTC (permalink / raw) To: Rasmus Villemoes Cc: linux-kbuild, pageexec, spender, kernel-hardening, mmarek, keescook On Mon, 08 Feb 2016 00:05:15 +0100 Rasmus Villemoes <linux@rasmusvillemoes.dk> wrote: > having all this in the main makefile. Can't all the plugin-related stuff > live in a separate makefile? The same goes for the Kconfig part. I will do the Makefile separation but I'm not sure about a separate arch/Kconfig.gcc-plugins as arch/Kconfig seems to be a general collection of arch/toolchain dependent features so I would rather stick to it until there is a general decision to break it up into smaller pieces. > Also, I think the compile command lines are already complicated enough > (I sometimes use V=1 to see what's going on), so I think it's better > that the plugins that need to make themselves known do so "from within" > gcc; something like > > static void define_feature_macro(void __unused *event_data, void __unused *data) > { > cpp_define(parse_in, "HAVE_ATTRIBUTE_FOOBAR"); > } I think it is better in the Makefile because -DPLUGIN doesn't matter much in the compile command compared to -fplugin and -fplugin-arg. An exmaple compile command with more plugins looks like this: gcc -Wp,-MD,fs/.exec.o.d -nostdinc -isystem /usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/include -I./arch/x86/include -Iarch/x86/include/generated/uapi -Iarch/x86/include/generated -Iinclude -I./arch/x86/include/uapi -Iarch/x86/include/generated/uapi -I./include/uapi -Iinclude/generated/uapi -include ./include/linux/kconfig.h -D__KERNEL__ -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -Werror-implicit-function-declaration -Wno-format-security -std=gnu89 -mno-sse -mno-mmx -mno-sse2 -mno-3dnow -mno-avx -m64 -falign-jumps=1 -falign-loops=1 -mno-80387 -mno-fp-ret-in-387 -mpreferred-stack-boundary=3 -mtune=generic -mno-red-zone -mcmodel=kernel -funit-at-a-time -maccumulate-outgoing-args -ffreestanding -DCONFIG_X86_X32_ABI -DCONFIG_AS_FXSAVEQ=1 -DCONFIG_AS_SSSE3=1 -DCONFIG_AS_CRC32=1 -DCONFIG_AS_AVX=1 -DCONFIG_AS_AVX2=1 -pipe -Wno-sign-compare -fno-asynchronous-unwind-tables -fno-delete-null-pointer-checks -Os -Wno-maybe-uninitialized --param=allow-store-data-races=0 -fno-reorder-blocks -fno-ipa-cp-clone -fno-partial-inlining -Wframe-larger-than=2048 -fno-stack-protector -Wno-unused-but-set-variable -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-var-tracking-assignments -fno-inline-functions-called-once -Wdeclaration-after-statement -Wno-pointer-sign -fno-strict-overflow -fconserve-stack -Werror=implicit-int -Werror=strict-prototypes -Werror=date-time -DCC_HAVE_ASM_GOTO -fplugin=./tools/gcc/stackleak_plugin.so -DSTACKLEAK_PLUGIN -fplugin-arg-stackleak_plugin-track-lowest-sp=100 -fplugin=./tools/gcc/colorize_plugin.so -fplugin=./tools/gcc/size_overflow_plugin/size_overflow_plugin.so -DSIZE_OVERFLOW_PLUGIN -fplugin=./tools/gcc/latent_entropy_plugin.so -DLATENT_ENTROPY_PLUGIN -fplugin=./tools/gcc/structleak_plugin.so -DSTRUCTLEAK_PLUGIN -fplugin=./tools/gcc/initify_plugin.so -DINITIFY_PLUGIN -fplugin=./tools/gcc/randomize_layout_plugin.so -DRANDSTRUCT_PLUGIN -fplugin-arg-randomize_layout_plugin-performance-mode -D"KBUILD_STR(s)=#s" -D"KBUILD_BASENAME=KBUILD_STR(exec)" -D"KBUILD_MODNAME=KBUILD_STR(exec)" -c -o fs/.tmp_exec.o fs/exec.c > > +#if BUILDING_GCC_VERSION >= 4009 > > +namespace { > > +static const struct pass_data cyc_complexity_pass_data = { > > +#else > > +static struct gimple_opt_pass cyc_complexity_pass = { > > + .pass = { > > +#endif > > + .type = GIMPLE_PASS, > > + .name = "cyc_complexity", > > +#if BUILDING_GCC_VERSION >= 4008 > > + .optinfo_flags = OPTGROUP_NONE, > > +#endif > > +#if BUILDING_GCC_VERSION >= 5000 > > +#elif BUILDING_GCC_VERSION >= 4009 > > + .has_gate = false, > > + .has_execute = true, > > +#else > > + .gate = NULL, > > + .execute = handle_function, > > + .sub = NULL, > > + .next = NULL, > > + .static_pass_number = 0, > > +#endif > > + .tv_id = TV_NONE, > > + .properties_required = 0, > > + .properties_provided = 0, > > + .properties_destroyed = 0, > > + .todo_flags_start = 0, > > + .todo_flags_finish = TODO_dump_func > > +#if BUILDING_GCC_VERSION < 4009 > > + } > > +#endif > > +}; > > + > > This is really yucky. Is there any way a mere mortal could figure out > how to write this? Or could the compatibility layer provide some utility > macros that would take care of the boilerplate? Yes, it isn't too nice but if I put them into macros (for GIMPLE, IPA and RTL) then they would have a lot of parameters because the user can and must define too many values (especially for an IPA pass which has even more fields). The compatibility with all gcc versions makes it further complicated so I think the end result would be uglier than it is now. -- Emese ^ permalink raw reply [flat|nested] 13+ messages in thread
* [kernel-hardening] Re: [PATCH 2/3] Add Cyclomatic complexity GCC plugin 2016-02-07 21:31 ` [kernel-hardening] [PATCH 2/3] Add Cyclomatic complexity GCC plugin Emese Revfy 2016-02-07 23:05 ` [kernel-hardening] " Rasmus Villemoes @ 2016-02-09 4:23 ` Kees Cook 2016-02-09 18:55 ` Emese Revfy 1 sibling, 1 reply; 13+ messages in thread From: Kees Cook @ 2016-02-09 4:23 UTC (permalink / raw) To: Emese Revfy Cc: linux-kbuild, PaX Team, Brad Spengler, kernel-hardening@lists.openwall.com, Michal Marek On Sun, Feb 7, 2016 at 1:31 PM, Emese Revfy <re.emese@gmail.com> wrote: > Add a very simple plugin to demonstrate the GCC plugin infrastructure. This GCC > plugin computes the cyclomatic complexity of each function. > > The complexity M of a function's control flow graph is defined as: > M = E - N + 2P > where > E = the number of edges > N = the number of nodes > P = the number of connected components (exit nodes). > > --- > Makefile | 6 +- > arch/Kconfig | 16 +++++ > tools/gcc/Makefile | 4 ++ > tools/gcc/cyc_complexity_plugin.c | 120 ++++++++++++++++++++++++++++++++++++++ > 4 files changed, 145 insertions(+), 1 deletion(-) > create mode 100644 tools/gcc/cyc_complexity_plugin.c > > diff --git a/Makefile b/Makefile > index 96ce015..9f76c26 100644 > --- a/Makefile > +++ b/Makefile > @@ -628,7 +628,11 @@ else > PLUGINCC := $(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-plugin.sh "$(HOSTCC)" "$(HOSTCXX)" "$(CC)") > endif > ifneq ($(PLUGINCC),) > -export PLUGINCC GCC_PLUGINS_CFLAGS GCC_PLUGINS_AFLAGS > +ifdef CONFIG_GCC_PLUGIN_CYC_COMPLEXITY > +GCC_PLUGIN_CYC_COMPLEXITY_CFLAGS := -fplugin=$(objtree)/tools/gcc/cyc_complexity_plugin.so -DGCC_PLUGIN_CYC_COMPLEXITY > +endif > +GCC_PLUGINS_CFLAGS := $(GCC_PLUGIN_CYC_COMPLEXITY_CFLAGS) > +export PLUGINCC GCC_PLUGINS_CFLAGS GCC_PLUGINS_AFLAGS GCC_PLUGIN_CYC_COMPLEXITY > ifeq ($(KBUILD_EXTMOD),) > gcc-plugins: > $(Q)$(MAKE) $(build)=tools/gcc > diff --git a/arch/Kconfig b/arch/Kconfig > index a95e5b1..6b7d4de 100644 > --- a/arch/Kconfig > +++ b/arch/Kconfig > @@ -365,6 +365,22 @@ config HAVE_GCC_PLUGINS > An arch should select this symbol if it supports building with > gcc plugins. > > +if HAVE_GCC_PLUGINS > + > +config GCC_PLUGIN_CYC_COMPLEXITY > + bool "Compute the cyclomatic complexity of a function" > + help Rather than the "if HAVE_GCC_PLUGINS" / endif section, I would add "depends HAVE_GCC_PLUGINS" to the config, which makes things more discoverable. > + The complexity M of a function's control flow graph is defined as: > + M = E - N + 2P > + where > + > + E = the number of edges > + N = the number of nodes > + P = the number of connected components (exit nodes). > + > + See Documentation/gcc-plugins.txt for details. Is this plugin documented there? I don't see a chunk for that in this patch. > + > +endif # HAVE_GCC_PLUGINS > endmenu # "GCC plugins" > > config HAVE_CC_STACKPROTECTOR > diff --git a/tools/gcc/Makefile b/tools/gcc/Makefile > index b2d64af..31c72bf 100644 > --- a/tools/gcc/Makefile > +++ b/tools/gcc/Makefile > @@ -12,4 +12,8 @@ endif > > export GCCPLUGINS_DIR HOSTLIBS > > +$(HOSTLIBS)-$(CONFIG_GCC_PLUGIN_CYC_COMPLEXITY) := cyc_complexity_plugin.so > + > always := $($(HOSTLIBS)-y) > + > +cyc_complexity_plugin-objs := cyc_complexity_plugin.o > diff --git a/tools/gcc/cyc_complexity_plugin.c b/tools/gcc/cyc_complexity_plugin.c > new file mode 100644 > index 0000000..c6f0d58 > --- /dev/null > +++ b/tools/gcc/cyc_complexity_plugin.c > @@ -0,0 +1,120 @@ > +/* > + * Copyright 2011-2016 by Emese Revfy <re.emese@gmail.com> > + * Licensed under the GPL v2, or (at your option) v3 > + * > + * Homepage: > + * https://github.com/ephox-gcc-plugins/cyclomatic_complexity > + * > + * http://en.wikipedia.org/wiki/Cyclomatic_complexity > + * The complexity M is then defined as: > + * M = E - N + 2P > + * where > + * > + * E = the number of edges of the graph > + * N = the number of nodes of the graph > + * P = the number of connected components (exit nodes). > + * > + * Usage (4.5 - 5): > + * $ make clean; make run > + */ > + > +#include "gcc-common.h" > + > +int plugin_is_GPL_compatible; > + > +static struct plugin_info cyc_complexity_plugin_info = { > + .version = "20150523", > + .help = "Cyclomatic Complexity\n", > +}; > + > +static unsigned int handle_function(void) > +{ > + int complexity; > + expanded_location xloc; > + > + // M = E - N + 2P > + complexity = n_edges_for_fn(cfun) - n_basic_blocks_for_fn(cfun) + 2; > + > + xloc = expand_location(DECL_SOURCE_LOCATION(current_function_decl)); > + fprintf(stderr, "Cyclomatic Complexity %d %s:%s\n", complexity, xloc.file, DECL_NAME_POINTER(current_function_decl)); > + > + return 0; > +} > + > +#if BUILDING_GCC_VERSION >= 4009 > +namespace { > +static const struct pass_data cyc_complexity_pass_data = { > +#else > +static struct gimple_opt_pass cyc_complexity_pass = { > + .pass = { > +#endif > + .type = GIMPLE_PASS, > + .name = "cyc_complexity", > +#if BUILDING_GCC_VERSION >= 4008 > + .optinfo_flags = OPTGROUP_NONE, > +#endif > +#if BUILDING_GCC_VERSION >= 5000 > +#elif BUILDING_GCC_VERSION >= 4009 > + .has_gate = false, > + .has_execute = true, > +#else > + .gate = NULL, > + .execute = handle_function, > + .sub = NULL, > + .next = NULL, > + .static_pass_number = 0, > +#endif > + .tv_id = TV_NONE, > + .properties_required = 0, > + .properties_provided = 0, > + .properties_destroyed = 0, > + .todo_flags_start = 0, > + .todo_flags_finish = TODO_dump_func > +#if BUILDING_GCC_VERSION < 4009 > + } > +#endif > +}; > + > +#if BUILDING_GCC_VERSION >= 4009 > +class cyc_complexity_pass : public gimple_opt_pass { > +public: > + cyc_complexity_pass() : gimple_opt_pass(cyc_complexity_pass_data, g) {} > +#if BUILDING_GCC_VERSION >= 5000 > + virtual unsigned int execute(function *) { return handle_function(); } > +#else > + unsigned int execute() { return handle_function(); } > +#endif > +}; > +} > + > +static struct opt_pass *make_cyc_complexity_pass(void) > +{ > + return new cyc_complexity_pass(); > +} > +#else > +static struct opt_pass *make_cyc_complexity_pass(void) > +{ > + return &cyc_complexity_pass.pass; > +} > +#endif > + > +int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gcc_version *version) > +{ > + const char * const plugin_name = plugin_info->base_name; > + struct register_pass_info cyc_complexity_pass_info; > + > + cyc_complexity_pass_info.pass = make_cyc_complexity_pass(); > + cyc_complexity_pass_info.reference_pass_name = "ssa"; > + cyc_complexity_pass_info.ref_pass_instance_number = 1; > + cyc_complexity_pass_info.pos_op = PASS_POS_INSERT_AFTER; > + > + if (!plugin_default_version_check(version, &gcc_version)) { > + error(G_("incompatible gcc/plugin versions")); > + return 1; > + } > + > + register_callback(plugin_name, PLUGIN_INFO, NULL, &cyc_complexity_plugin_info); > + register_callback(plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &cyc_complexity_pass_info); > + > + return 0; > +} > -- Kees Cook Chrome OS & Brillo Security ^ permalink raw reply [flat|nested] 13+ messages in thread
* [kernel-hardening] Re: [PATCH 2/3] Add Cyclomatic complexity GCC plugin 2016-02-09 4:23 ` Kees Cook @ 2016-02-09 18:55 ` Emese Revfy 0 siblings, 0 replies; 13+ messages in thread From: Emese Revfy @ 2016-02-09 18:55 UTC (permalink / raw) To: Kees Cook Cc: linux-kbuild, PaX Team, Brad Spengler, kernel-hardening@lists.openwall.com, Michal Marek On Mon, 8 Feb 2016 20:23:12 -0800 Kees Cook <keescook@chromium.org> wrote: > > + The complexity M of a function's control flow graph is defined as: > > + M = E - N + 2P > > + where > > + > > + E = the number of edges > > + N = the number of nodes > > + P = the number of connected components (exit nodes). > > + > > + See Documentation/gcc-plugins.txt for details. > > Is this plugin documented there? I don't see a chunk for that in this patch. No yet, please see my other response. -- Emese ^ permalink raw reply [flat|nested] 13+ messages in thread
* [kernel-hardening] [PATCH 3/3] Documentation for the GCC plugin infrastructure 2016-02-07 21:27 [kernel-hardening] [PATCH 0/3] Introduce GCC plugin infrastructure Emese Revfy 2016-02-07 21:28 ` [kernel-hardening] [PATCH 1/3] " Emese Revfy 2016-02-07 21:31 ` [kernel-hardening] [PATCH 2/3] Add Cyclomatic complexity GCC plugin Emese Revfy @ 2016-02-07 21:32 ` Emese Revfy 2016-02-09 4:27 ` [kernel-hardening] " Kees Cook 2 siblings, 1 reply; 13+ messages in thread From: Emese Revfy @ 2016-02-07 21:32 UTC (permalink / raw) To: linux-kbuild; +Cc: pageexec, spender, kernel-hardening, mmarek, keescook This is the GCC infrastructure documentation about its operation, how to add and use a new plugin with an example. --- Documentation/example_gcc_plugin.c | 103 +++++++++++++++++++++++++++++++++++++ Documentation/gcc-plugins.txt | 76 +++++++++++++++++++++++++++ 2 files changed, 179 insertions(+) create mode 100644 Documentation/example_gcc_plugin.c create mode 100644 Documentation/gcc-plugins.txt diff --git a/Documentation/example_gcc_plugin.c b/Documentation/example_gcc_plugin.c new file mode 100644 index 0000000..950ff78 --- /dev/null +++ b/Documentation/example_gcc_plugin.c @@ -0,0 +1,103 @@ +/* + * Copyright 2011-2016 by Emese Revfy <re.emese@gmail.com> + * Licensed under the GPL v2, or (at your option) v3 + */ + +#include "gcc-common.h" + +int plugin_is_GPL_compatible; + +static struct plugin_info example_plugin_info = { + .version = "0", + .help = "example plugin\n", +}; + +static unsigned int handle_function(void) +{ + gimple_stmt_iterator gsi; + basic_block bb; + + FOR_ALL_BB_FN(bb, cfun) { + for (gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) + debug_gimple_stmt(gsi_stmt(gsi)); + } + return 0; +} + +#if BUILDING_GCC_VERSION >= 4009 +namespace { +static const struct pass_data example_plugin_pass_data = { +#else +static struct gimple_opt_pass example_plugin_pass = { + .pass = { +#endif + .type = GIMPLE_PASS, + .name = "example_plugin", +#if BUILDING_GCC_VERSION >= 4008 + .optinfo_flags = OPTGROUP_NONE, +#endif +#if BUILDING_GCC_VERSION >= 5000 +#elif BUILDING_GCC_VERSION >= 4009 + .has_gate = false, + .has_execute = true, +#else + .gate = NULL, + .execute = handle_function, + .sub = NULL, + .next = NULL, + .static_pass_number = 0, +#endif + .tv_id = TV_NONE, + .properties_required = 0, + .properties_provided = 0, + .properties_destroyed = 0, + .todo_flags_start = 0, + .todo_flags_finish = TODO_dump_func +#if BUILDING_GCC_VERSION < 4009 + } +#endif +}; + +#if BUILDING_GCC_VERSION >= 4009 +class example_plugin_pass : public gimple_opt_pass { +public: + example_plugin_pass() : gimple_opt_pass(example_plugin_pass_data, g) {} +#if BUILDING_GCC_VERSION >= 5000 + virtual unsigned int execute(function *) { return handle_function(); } +#else + unsigned int execute() { return handle_function(); } +#endif +}; +} + +static opt_pass *make_example_plugin_pass(void) +{ + return new example_plugin_pass(); +} +#else +static struct opt_pass *make_example_plugin_pass(void) +{ + return &example_plugin_pass.pass; +} +#endif + +int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gcc_version *version) +{ + const char * const plugin_name = plugin_info->base_name; + struct register_pass_info example_plugin_pass_info; + + example_plugin_pass_info.pass = make_example_plugin_pass(); + example_plugin_pass_info.reference_pass_name = "ssa"; + example_plugin_pass_info.ref_pass_instance_number = 1; + example_plugin_pass_info.pos_op = PASS_POS_INSERT_AFTER; + + if (!plugin_default_version_check(version, &gcc_version)) { + error(G_("incompatible gcc/plugin versions")); + return 1; + } + + register_callback(plugin_name, PLUGIN_INFO, NULL, &example_plugin_info); + register_callback(plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &example_plugin_pass_info); + + return 0; +} diff --git a/Documentation/gcc-plugins.txt b/Documentation/gcc-plugins.txt new file mode 100644 index 0000000..e669d83 --- /dev/null +++ b/Documentation/gcc-plugins.txt @@ -0,0 +1,76 @@ +GCC plugin infrastructure +========================= + + +1. Introduction +=============== + +GCC plugins are loadable modules that provide extra features to the +compiler [1]. They are useful for runtime instrumentation and static analysis. +We can analyse, change and add further code during compilation via +callbacks [2], GIMPLE [3], IPA [4] and RTL passes [5]. + +The GCC plugin infrastructure of the kernel supports all gcc versions from +4.5 to 6.0, building out-of-tree modules, cross-compilation and building in a +separate directory. + +Currently the GCC plugin infrastructure supports only the x86 architecture. + +This infrastructure was ported from grsecurity [6] and PaX [7]. + +-- +[1] https://gcc.gnu.org/onlinedocs/gccint/Plugins.html +[2] https://gcc.gnu.org/onlinedocs/gccint/Plugin-API.html#Plugin-API +[3] https://gcc.gnu.org/onlinedocs/gccint/GIMPLE.html +[4] https://gcc.gnu.org/onlinedocs/gccint/IPA.html +[5] https://gcc.gnu.org/onlinedocs/gccint/RTL.html +[6] https://grsecurity.net/ +[7] https://pax.grsecurity.net/ + + +2. Files +======== + +$(src)/tools/gcc + This is the directory of the GCC plugins. + +$(src)/tools/gcc/gcc-common.h + This is a compatibility header for GCC plugins. + It should be always included instead of individual gcc headers. + +$(src)/scripts/gcc-plugin.sh + This script checks the availability of the included headers in + gcc-common.h and chooses the proper host compiler to build the plugins + (gcc-4.7 can be built by either gcc or g++). + + +3. Usage +======== + +Enable a GCC plugin based feature in the kernel config: + + CONFIG_GCC_PLUGIN_CYC_COMPLEXITY = y + +To compile only the plugin(s): + + make gcc-plugins + +or just run the kernel make and compile the whole kernel with +the cyclomatic complexity GCC plugin. + + +4. How to add a new GCC plugin +============================== + +The GCC plugins are in $(src)/tools/gcc/. You can use a file or a directory +here. It must be added to $(src)/tools/gcc/Makefile, $(src)/Makefile and +$(src)/arch/Kconfig. +See the cyc_complexity_plugin.c (CONFIG_GCC_PLUGIN_CYC_COMPLEXITY) GCC plugin. + + +5. Example GCC plugin +===================== + +You can find an example plugin under $(src)/Documentation/example_gcc_plugin.c . +This plugin has a GIMPLE pass that is inserted after the ssa GCC pass. +It prints out all the GIMPLE statements in a translation unit. ^ permalink raw reply related [flat|nested] 13+ messages in thread
* [kernel-hardening] Re: [PATCH 3/3] Documentation for the GCC plugin infrastructure 2016-02-07 21:32 ` [kernel-hardening] [PATCH 3/3] Documentation for the GCC plugin infrastructure Emese Revfy @ 2016-02-09 4:27 ` Kees Cook 2016-02-09 19:14 ` Emese Revfy 0 siblings, 1 reply; 13+ messages in thread From: Kees Cook @ 2016-02-09 4:27 UTC (permalink / raw) To: Emese Revfy Cc: linux-kbuild, PaX Team, Brad Spengler, kernel-hardening@lists.openwall.com, Michal Marek, linux-doc@vger.kernel.org On Sun, Feb 7, 2016 at 1:32 PM, Emese Revfy <re.emese@gmail.com> wrote: > This is the GCC infrastructure documentation about its operation, how to add > and use a new plugin with an example. > > --- > Documentation/example_gcc_plugin.c | 103 +++++++++++++++++++++++++++++++++++++ Perhaps this example should live in samples/gcc_plugin/ ? > Documentation/gcc-plugins.txt | 76 +++++++++++++++++++++++++++ > 2 files changed, 179 insertions(+) > create mode 100644 Documentation/example_gcc_plugin.c > create mode 100644 Documentation/gcc-plugins.txt > > diff --git a/Documentation/example_gcc_plugin.c b/Documentation/example_gcc_plugin.c > new file mode 100644 > index 0000000..950ff78 > --- /dev/null > +++ b/Documentation/example_gcc_plugin.c > @@ -0,0 +1,103 @@ > +/* > + * Copyright 2011-2016 by Emese Revfy <re.emese@gmail.com> > + * Licensed under the GPL v2, or (at your option) v3 > + */ > + > +#include "gcc-common.h" > + > +int plugin_is_GPL_compatible; > + > +static struct plugin_info example_plugin_info = { > + .version = "0", > + .help = "example plugin\n", > +}; > + > +static unsigned int handle_function(void) > +{ > + gimple_stmt_iterator gsi; > + basic_block bb; > + > + FOR_ALL_BB_FN(bb, cfun) { > + for (gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) > + debug_gimple_stmt(gsi_stmt(gsi)); > + } > + return 0; > +} > + > +#if BUILDING_GCC_VERSION >= 4009 > +namespace { > +static const struct pass_data example_plugin_pass_data = { > +#else > +static struct gimple_opt_pass example_plugin_pass = { > + .pass = { > +#endif > + .type = GIMPLE_PASS, > + .name = "example_plugin", > +#if BUILDING_GCC_VERSION >= 4008 > + .optinfo_flags = OPTGROUP_NONE, > +#endif > +#if BUILDING_GCC_VERSION >= 5000 > +#elif BUILDING_GCC_VERSION >= 4009 > + .has_gate = false, > + .has_execute = true, > +#else > + .gate = NULL, > + .execute = handle_function, > + .sub = NULL, > + .next = NULL, > + .static_pass_number = 0, > +#endif > + .tv_id = TV_NONE, > + .properties_required = 0, > + .properties_provided = 0, > + .properties_destroyed = 0, > + .todo_flags_start = 0, > + .todo_flags_finish = TODO_dump_func > +#if BUILDING_GCC_VERSION < 4009 > + } > +#endif > +}; > + > +#if BUILDING_GCC_VERSION >= 4009 > +class example_plugin_pass : public gimple_opt_pass { > +public: > + example_plugin_pass() : gimple_opt_pass(example_plugin_pass_data, g) {} > +#if BUILDING_GCC_VERSION >= 5000 > + virtual unsigned int execute(function *) { return handle_function(); } > +#else > + unsigned int execute() { return handle_function(); } > +#endif > +}; > +} > + > +static opt_pass *make_example_plugin_pass(void) > +{ > + return new example_plugin_pass(); > +} > +#else > +static struct opt_pass *make_example_plugin_pass(void) > +{ > + return &example_plugin_pass.pass; > +} > +#endif > + > +int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gcc_version *version) > +{ > + const char * const plugin_name = plugin_info->base_name; > + struct register_pass_info example_plugin_pass_info; > + > + example_plugin_pass_info.pass = make_example_plugin_pass(); > + example_plugin_pass_info.reference_pass_name = "ssa"; > + example_plugin_pass_info.ref_pass_instance_number = 1; > + example_plugin_pass_info.pos_op = PASS_POS_INSERT_AFTER; > + > + if (!plugin_default_version_check(version, &gcc_version)) { > + error(G_("incompatible gcc/plugin versions")); > + return 1; > + } > + > + register_callback(plugin_name, PLUGIN_INFO, NULL, &example_plugin_info); > + register_callback(plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &example_plugin_pass_info); > + > + return 0; > +} For an example, I'd expect verbose comments. :) Imagine someone reading it who knows very little about plugins or compiler internals. > diff --git a/Documentation/gcc-plugins.txt b/Documentation/gcc-plugins.txt > new file mode 100644 > index 0000000..e669d83 > --- /dev/null > +++ b/Documentation/gcc-plugins.txt > @@ -0,0 +1,76 @@ > +GCC plugin infrastructure > +========================= > + > + > +1. Introduction > +=============== > + > +GCC plugins are loadable modules that provide extra features to the > +compiler [1]. They are useful for runtime instrumentation and static analysis. > +We can analyse, change and add further code during compilation via > +callbacks [2], GIMPLE [3], IPA [4] and RTL passes [5]. > + > +The GCC plugin infrastructure of the kernel supports all gcc versions from > +4.5 to 6.0, building out-of-tree modules, cross-compilation and building in a > +separate directory. > + > +Currently the GCC plugin infrastructure supports only the x86 architecture. > + > +This infrastructure was ported from grsecurity [6] and PaX [7]. > + > +-- > +[1] https://gcc.gnu.org/onlinedocs/gccint/Plugins.html > +[2] https://gcc.gnu.org/onlinedocs/gccint/Plugin-API.html#Plugin-API > +[3] https://gcc.gnu.org/onlinedocs/gccint/GIMPLE.html > +[4] https://gcc.gnu.org/onlinedocs/gccint/IPA.html > +[5] https://gcc.gnu.org/onlinedocs/gccint/RTL.html > +[6] https://grsecurity.net/ > +[7] https://pax.grsecurity.net/ > + > + > +2. Files > +======== > + > +$(src)/tools/gcc > + This is the directory of the GCC plugins. > + > +$(src)/tools/gcc/gcc-common.h > + This is a compatibility header for GCC plugins. > + It should be always included instead of individual gcc headers. > + > +$(src)/scripts/gcc-plugin.sh > + This script checks the availability of the included headers in > + gcc-common.h and chooses the proper host compiler to build the plugins > + (gcc-4.7 can be built by either gcc or g++). > + > + > +3. Usage > +======== > + > +Enable a GCC plugin based feature in the kernel config: > + > + CONFIG_GCC_PLUGIN_CYC_COMPLEXITY = y > + > +To compile only the plugin(s): > + > + make gcc-plugins > + > +or just run the kernel make and compile the whole kernel with > +the cyclomatic complexity GCC plugin. > + > + > +4. How to add a new GCC plugin > +============================== > + > +The GCC plugins are in $(src)/tools/gcc/. You can use a file or a directory > +here. It must be added to $(src)/tools/gcc/Makefile, $(src)/Makefile and > +$(src)/arch/Kconfig. > +See the cyc_complexity_plugin.c (CONFIG_GCC_PLUGIN_CYC_COMPLEXITY) GCC plugin. > + > + > +5. Example GCC plugin > +===================== > + > +You can find an example plugin under $(src)/Documentation/example_gcc_plugin.c . > +This plugin has a GIMPLE pass that is inserted after the ssa GCC pass. > +It prints out all the GIMPLE statements in a translation unit. -Kees -- Kees Cook Chrome OS & Brillo Security ^ permalink raw reply [flat|nested] 13+ messages in thread
* [kernel-hardening] Re: [PATCH 3/3] Documentation for the GCC plugin infrastructure 2016-02-09 4:27 ` [kernel-hardening] " Kees Cook @ 2016-02-09 19:14 ` Emese Revfy 0 siblings, 0 replies; 13+ messages in thread From: Emese Revfy @ 2016-02-09 19:14 UTC (permalink / raw) To: Kees Cook Cc: linux-kbuild, PaX Team, Brad Spengler, kernel-hardening@lists.openwall.com, Michal Marek, linux-doc@vger.kernel.org On Mon, 8 Feb 2016 20:27:31 -0800 Kees Cook <keescook@chromium.org> wrote: > On Sun, Feb 7, 2016 at 1:32 PM, Emese Revfy <re.emese@gmail.com> wrote: > > This is the GCC infrastructure documentation about its operation, how to add > > and use a new plugin with an example. > > > > --- > > Documentation/example_gcc_plugin.c | 103 +++++++++++++++++++++++++++++++++++++ > > Perhaps this example should live in samples/gcc_plugin/ ? Perhaps the example plugin is unnecessary. I should use the cyclomatic complexity plugin because I already wrote about it in the sections "Usage" and "How to add a new GCC plugin" and they differ by only two lines. > For an example, I'd expect verbose comments. :) Imagine someone > reading it who knows very little about plugins or compiler internals. I think gcc has very good documentation about plugins, I reference them from gcc-plugins.txt, you can see it below. If you think it isn't enough tell me please what you would like to see as additional documentation. > > +1. Introduction > > +=============== > > + > > +GCC plugins are loadable modules that provide extra features to the > > +compiler [1]. They are useful for runtime instrumentation and static analysis. > > +We can analyse, change and add further code during compilation via > > +callbacks [2], GIMPLE [3], IPA [4] and RTL passes [5]. > > + > > +The GCC plugin infrastructure of the kernel supports all gcc versions from > > +4.5 to 6.0, building out-of-tree modules, cross-compilation and building in a > > +separate directory. > > + > > +Currently the GCC plugin infrastructure supports only the x86 architecture. > > + > > +This infrastructure was ported from grsecurity [6] and PaX [7]. > > + > > +-- > > +[1] https://gcc.gnu.org/onlinedocs/gccint/Plugins.html > > +[2] https://gcc.gnu.org/onlinedocs/gccint/Plugin-API.html#Plugin-API > > +[3] https://gcc.gnu.org/onlinedocs/gccint/GIMPLE.html > > +[4] https://gcc.gnu.org/onlinedocs/gccint/IPA.html > > +[5] https://gcc.gnu.org/onlinedocs/gccint/RTL.html > > +[6] https://grsecurity.net/ > > +[7] https://pax.grsecurity.net/ -- Emese ^ permalink raw reply [flat|nested] 13+ messages in thread
* [kernel-hardening] Re: [PATCH 1/3] GCC plugin infrastructure
@ 2016-02-09 4:20 Kees Cook
0 siblings, 0 replies; 13+ messages in thread
From: Kees Cook @ 2016-02-09 4:20 UTC (permalink / raw)
To: Emese Revfy
Cc: Michal Marek, linux-kbuild, PaX Team, Brad Spengler,
kernel-hardening@lists.openwall.com
On Mon, Feb 8, 2016 at 1:31 PM, Emese Revfy <re.emese@gmail.com> wrote:
> On Mon, 8 Feb 2016 21:28:13 +0100
> Michal Marek <mmarek@suse.com> wrote:
>
>> Dne 7.2.2016 v 22:28 Emese Revfy napsal(a):
>> > This patch allows to build the whole kernel with GCC plugins. It was ported from
>> > grsecurity/PaX. The infrastructure supports building out-of-tree modules and
>> > building in a separate directory. Cross-compilation is supported too but
>> > currently only the x86 architecture enables plugins.
>> >
>> > The directory of the gcc plugins is tools/gcc. You can use a file or a directory
>> > there. The plugins compile with these options:
>> > * -fno-rtti: gcc is compiled with this option so the plugins must use it too
>> > * -fno-exceptions: this is inherited from gcc too
>> > * -fasynchronous-unwind-tables: this is inherited from gcc too
>> > * -ggdb: it is useful for debugging a plugin (better backtrace on internal
>> > errors)
>> > * -Wno-narrowing: to suppress warnings from gcc headers (ipa-utils.h)
>> > * -Wno-unused-variable: to suppress warnings from gcc headers (gcc_version
>> > variable, plugin-version.h)
>> >
>> > The infrastructure introduces a new Makefile target called gcc-plugins. It
>> > supports all gcc versions from 4.5 to 6.0. The scripts/gcc-plugin.sh script
>> > chooses the proper host compiler (gcc-4.7 can be built by either gcc or g++).
>> > This script also checks the availability of the included headers in
>> > tools/gcc/gcc-common.h.
>> >
>> > The gcc-common.h header contains frequently included headers for GCC plugins
>> > and it has a compatibility layer for the supported gcc versions.
>>
>> The changelog is missing an explanation as to why this needs to be part
>> of the kernel build system. To me it looks like building the kernel with
>> a modified build system and non-default compiler flags, which can be
>> achieved by doing make CC=my-gcc-wrapper or somesuch. But I'd love to be
>> corrected.
>
> These compiler options compile the gcc plugins not the kernel. The new gcc option
> used for building the kernel is the -fplugin option.
Since these plugins will be used as part of kernel builds and
controlled with CONFIG settings in the future, we want to make sure
they're part of the kernel tree itself. The end goal is gaining the
security benefits of the constify and size_overflow plugins, but that
requires the plugin infrastructure itself first. For example, I would
ultimately expect to see constify on by default after some initial
testing.
-Kees
--
Kees Cook
Chrome OS & Brillo Security
^ permalink raw reply [flat|nested] 13+ messages in threadend of thread, other threads:[~2016-02-09 19:14 UTC | newest] Thread overview: 13+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2016-02-07 21:27 [kernel-hardening] [PATCH 0/3] Introduce GCC plugin infrastructure Emese Revfy 2016-02-07 21:28 ` [kernel-hardening] [PATCH 1/3] " Emese Revfy 2016-02-08 20:28 ` [kernel-hardening] " Michal Marek 2016-02-08 21:31 ` Emese Revfy 2016-02-07 21:31 ` [kernel-hardening] [PATCH 2/3] Add Cyclomatic complexity GCC plugin Emese Revfy 2016-02-07 23:05 ` [kernel-hardening] " Rasmus Villemoes 2016-02-08 21:20 ` Emese Revfy 2016-02-09 4:23 ` Kees Cook 2016-02-09 18:55 ` Emese Revfy 2016-02-07 21:32 ` [kernel-hardening] [PATCH 3/3] Documentation for the GCC plugin infrastructure Emese Revfy 2016-02-09 4:27 ` [kernel-hardening] " Kees Cook 2016-02-09 19:14 ` Emese Revfy -- strict thread matches above, loose matches on Subject: below -- 2016-02-09 4:20 [kernel-hardening] Re: [PATCH 1/3] " Kees Cook
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 NNTP newsgroup(s).