Commit 4b3e5c06 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/bonzini/tags/for-upstream' into staging 



* pc-bios/optionrom/Makefile fixes
* warning fixes for __atomic_load and -1 << x in clang
* missed interrupt fix from Gonglei
* checkpatch fix from Radim and myself

# gpg: Signature made Wed 10 Aug 2016 14:54:31 BST
# gpg:                using RSA key 0xBFFBD25F78C7AE83
# gpg: Good signature from "Paolo Bonzini <bonzini@gnu.org>"
# gpg:                 aka "Paolo Bonzini <pbonzini@redhat.com>"
# Primary key fingerprint: 46F5 9FBD 57D6 12E7 BFD4  E2F7 7E15 100C CD36 69B1
#      Subkey fingerprint: F133 3857 4B66 2389 866C  7682 BFFB D25F 78C7 AE83

* remotes/bonzini/tags/for-upstream:
  checkpatch: default to success if only warnings
  checkpatch: bump most warnings to errors
  CODING_STYLE, checkpatch: update line length rules
  checkpatch: check for CVS keywords on all sources
  checkpatch: tweak the files in which TABs are checked
  timer: set vm_clock disabled default
  checkpatch: ignore automatically imported Linux headers
  clang: Fix warning reg. expansion to 'defined'
  Disable warn about left shifts of negative values
  atomic: strip "const" from variables declared with typeof
  optionrom: fix compilation with mingw docker target
  optionrom: add -fno-stack-protector
  build-sys: fix building with make CFLAGS=.. argument
  linuxboot_dma: avoid guest ABI breakage on gcc vs. clang compilation

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents d578cca3 141de886

CODING_STYLE

+7 −1
Original line number Diff line number Diff line
@@ -31,7 +31,11 @@ Do not leave whitespace dangling off the ends of lines. 


2. Line width



Lines are 80 characters; not longer.

Lines should be 80 characters; try not to make them longer.



Sometimes it is hard to do, especially when dealing with QEMU subsystems

that use long function or symbol names.  Even in that case, do not make

lines much longer than 80 characters.



Rationale:

 - Some people like to tile their 24" screens with a 6x4 matrix of 80x24
@@ -39,6 +43,8 @@ Rationale: 
   let them keep doing it.

 - Code and especially patches is much more readable if limited to a sane

   line length.  Eighty is traditional.

 - The four-space indentation makes the most common excuse ("But look

   at all that white space on the left!") moot.

 - It is the QEMU coding style.



3. Naming

HACKING

+4 −0
Original line number Diff line number Diff line
@@ -158,6 +158,10 @@ painful. These are: 
 * you may assume that right shift of a signed integer duplicates

   the sign bit (ie it is an arithmetic shift, not a logical shift)



In addition, QEMU assumes that the compiler does not use the latitude

given in C99 and C11 to treat aspects of signed '<<' as undefined, as

documented in the GNU Compiler Collection manual starting at version 4.0.



7. Error handling and reporting



7.1 Reporting errors to the human user

Makefile

+2 −1
Original line number Diff line number Diff line
@@ -225,8 +225,9 @@ dtc/%: 
$(SUBDIR_RULES): libqemuutil.a libqemustub.a $(common-obj-y) $(qom-obj-y) $(crypto-aes-obj-$(CONFIG_USER_ONLY))



ROMSUBDIR_RULES=$(patsubst %,romsubdir-%, $(ROMS))

# Only keep -O and -g cflags

romsubdir-%:

	$(call quiet-command,$(MAKE) $(SUBDIR_MAKEFLAGS) -C pc-bios/$* V="$(V)" TARGET_DIR="$*/",)

	$(call quiet-command,$(MAKE) $(SUBDIR_MAKEFLAGS) -C pc-bios/$* V="$(V)" TARGET_DIR="$*/" CFLAGS="$(filter -O% -g%,$(CFLAGS))",)



ALL_SUBDIRS=$(TARGET_DIRS) $(patsubst %,pc-bios/%, $(ROMS))

configure

+1 −1
Original line number Diff line number Diff line
@@ -1452,7 +1452,7 @@ fi 
gcc_flags="-Wold-style-declaration -Wold-style-definition -Wtype-limits"

gcc_flags="-Wformat-security -Wformat-y2k -Winit-self -Wignored-qualifiers $gcc_flags"

gcc_flags="-Wmissing-include-dirs -Wempty-body -Wnested-externs $gcc_flags"

gcc_flags="-Wendif-labels $gcc_flags"

gcc_flags="-Wendif-labels -Wno-shift-negative-value $gcc_flags"

gcc_flags="-Wno-initializer-overrides $gcc_flags"

gcc_flags="-Wno-string-plus-int $gcc_flags"

# Note that we do not add -Werror to gcc_flags here, because that would

include/qemu/atomic.h

+48 −6
Original line number Diff line number Diff line
@@ -18,6 +18,48 @@ 
/* Compiler barrier */

#define barrier()   ({ asm volatile("" ::: "memory"); (void)0; })



/* The variable that receives the old value of an atomically-accessed

 * variable must be non-qualified, because atomic builtins return values

 * through a pointer-type argument as in __atomic_load(&var, &old, MODEL).

 *

 * This macro has to handle types smaller than int manually, because of

 * implicit promotion.  int and larger types, as well as pointers, can be

 * converted to a non-qualified type just by applying a binary operator.

 */

#define typeof_strip_qual(expr)                                                    \

  typeof(                                                                          \

    __builtin_choose_expr(                                                         \

      __builtin_types_compatible_p(typeof(expr), bool) ||                          \

        __builtin_types_compatible_p(typeof(expr), const bool) ||                  \

        __builtin_types_compatible_p(typeof(expr), volatile bool) ||               \

        __builtin_types_compatible_p(typeof(expr), const volatile bool),           \

        (bool)1,                                                                   \

    __builtin_choose_expr(                                                         \

      __builtin_types_compatible_p(typeof(expr), signed char) ||                   \

        __builtin_types_compatible_p(typeof(expr), const signed char) ||           \

        __builtin_types_compatible_p(typeof(expr), volatile signed char) ||        \

        __builtin_types_compatible_p(typeof(expr), const volatile signed char),    \

        (signed char)1,                                                            \

    __builtin_choose_expr(                                                         \

      __builtin_types_compatible_p(typeof(expr), unsigned char) ||                 \

        __builtin_types_compatible_p(typeof(expr), const unsigned char) ||         \

        __builtin_types_compatible_p(typeof(expr), volatile unsigned char) ||      \

        __builtin_types_compatible_p(typeof(expr), const volatile unsigned char),  \

        (unsigned char)1,                                                          \

    __builtin_choose_expr(                                                         \

      __builtin_types_compatible_p(typeof(expr), signed short) ||                  \

        __builtin_types_compatible_p(typeof(expr), const signed short) ||          \

        __builtin_types_compatible_p(typeof(expr), volatile signed short) ||       \

        __builtin_types_compatible_p(typeof(expr), const volatile signed short),   \

        (signed short)1,                                                           \

    __builtin_choose_expr(                                                         \

      __builtin_types_compatible_p(typeof(expr), unsigned short) ||                \

        __builtin_types_compatible_p(typeof(expr), const unsigned short) ||        \

        __builtin_types_compatible_p(typeof(expr), volatile unsigned short) ||     \

        __builtin_types_compatible_p(typeof(expr), const volatile unsigned short), \

        (unsigned short)1,                                                         \

      (expr)+0))))))



#ifdef __ATOMIC_RELAXED

/* For C11 atomic ops */
@@ -54,7 +96,7 @@ 
#define atomic_read(ptr)                              \

    ({                                                \

    QEMU_BUILD_BUG_ON(sizeof(*ptr) > sizeof(void *)); \

    typeof(*ptr) _val;                                \

    typeof_strip_qual(*ptr) _val;                     \

     __atomic_load(ptr, &_val, __ATOMIC_RELAXED);     \

    _val;                                             \

    })
@@ -80,7 +122,7 @@ 
#define atomic_rcu_read(ptr)                          \

    ({                                                \

    QEMU_BUILD_BUG_ON(sizeof(*ptr) > sizeof(void *)); \

    typeof(*ptr) _val;                                \

    typeof_strip_qual(*ptr) _val;                     \

    atomic_rcu_read__nocheck(ptr, &_val);             \

    _val;                                             \

    })
@@ -103,7 +145,7 @@ 
#define atomic_mb_read(ptr)                             \

    ({                                                  \

    QEMU_BUILD_BUG_ON(sizeof(*ptr) > sizeof(void *));   \

    typeof(*ptr) _val;                                  \

    typeof_strip_qual(*ptr) _val;                       \

     __atomic_load(ptr, &_val, __ATOMIC_RELAXED);       \

     smp_rmb();                                         \

    _val;                                               \
@@ -120,7 +162,7 @@ 
#define atomic_mb_read(ptr)                             \

    ({                                                  \

    QEMU_BUILD_BUG_ON(sizeof(*ptr) > sizeof(void *));   \

    typeof(*ptr) _val;                                  \

    typeof_strip_qual(*ptr) _val;                       \

    __atomic_load(ptr, &_val, __ATOMIC_SEQ_CST);        \

    _val;                                               \

    })
@@ -137,7 +179,7 @@ 


#define atomic_xchg(ptr, i)    ({                           \

    QEMU_BUILD_BUG_ON(sizeof(*ptr) > sizeof(void *));       \

    typeof(*ptr) _new = (i), _old;                          \

    typeof_strip_qual(*ptr) _new = (i), _old;               \

    __atomic_exchange(ptr, &_new, &_old, __ATOMIC_SEQ_CST); \

    _old;                                                   \

})
@@ -146,7 +188,7 @@ 
#define atomic_cmpxchg(ptr, old, new)                                   \

    ({                                                                  \

    QEMU_BUILD_BUG_ON(sizeof(*ptr) > sizeof(void *));                   \

    typeof(*ptr) _old = (old), _new = (new);                            \

    typeof_strip_qual(*ptr) _old = (old), _new = (new);                 \

    __atomic_compare_exchange(ptr, &_old, &_new, false,                 \

                              __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);      \

    _old;                                                               \