[Driver] Default to -fno-common for all targets

[SjoerdMeijer]

Summary

This makes -fno-common the default for all targets because this has performance and code-size benefits and is more language conforming for C code. Additionally, GCC10 also defaults to -fno-common and so we get consistent behaviour with GCC.

With this change, C code that uses tentative definitions as definitions of a variable in multiple translation units will trigger multiple-definition linker errors. Generally, this occurs when the use of the extern keyword is neglected in the declaration of a variable in a header file. In some cases, no specific translation unit provides a definition of the variable. The previous behavior can be restored by specifying -fcommon.

As GCC has switched already, we benefit from applications already being ported and existing documentation how to do this. For example:

• https://gcc.gnu.org/gcc-10/porting_to.html
• https://wiki.gentoo.org/wiki/Gcc_10_porting_notes/fno_common

[SjoerdMeijer]

Following the discussion on the cfe dev list, this is a first draft to enable -fno-common for all targets.

TODO: doc changes.

[tstellar]

I am in favor of this change. Could you also add something to the release notes?

[SjoerdMeijer]

Thanks, have added a note to the release notes, and also to the command line reference.

[MaskRay]

clang/lib/Driver/ToolChains/Clang.cpp

5664

cc1 does not check -fcommon: Opts.NoCommon = Args.hasArg(OPT_fno_common);

I think you can flip it to Opts.NoCommon = !Args.hasArg(OPT_fcommon);

and change here to pass -fcommon if Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common, false)

[MaskRay]

clang/test/Driver/no-common.c

2

Just %clang -target %itanium_abi_triple

Delete all the targets.

[SjoerdMeijer]

Thanks for catching that. Now it shows more changes in tests, so updated a bunch of tests.

[SjoerdMeijer]

minor test update

[hubert.reinterpretcast]

I have no objections; however, it may help for the title of the patch to clearly indicate "for all targets".

[MaskRay]

clang/test/Driver/clang_f_opts.c

15

I think such NOT patterns should just be deleted.

(Note that NOT patterns tend to be insufficient due to order reasons)

-fcommon is a minority now. We only need to test it for an OS/Arch that really needs it (currently no).

[SjoerdMeijer]

Removed the CHECK-NOTs from some tests as suggested.

And as also suggested, made the title more descriptive.

Thanks for all suggestions!

[MaskRay]

LGTM. Hope @tstellar and @jyknight can confirm.

[jyknight]

Are there any tests remaining that check that with -fcommon, IR generation creates "common" variables, now that all these tests have been modified? If there are not, one should be added.

clang/docs/ClangCommandLineReference.rst

1311

Use "instead of generating" instead of "or generate".

Mention "This option has no effect in C++ mode."

clang/docs/ReleaseNotes.rst

87

Might be nice to expand upon this somewhat, to give users a clue what it means to them.

E.g.

Therefore, C code which uses multiple definitions of a global variable will trigger a multiple-definition linker errors. Generally this occurs when a variable in a header file neglects to use the "extern" keyword on the declaration. The previous behavior can be restored by specifying -fcommon.

[hubert.reinterpretcast]

clang/docs/ReleaseNotes.rst

87

Suggestion:
Therefore, C code that uses tentative definitions as definitions of a variable in multiple translation units will trigger multiple-definition linker errors. Generally, this occurs when the use of the extern keyword is neglected in the declaration of a variable in a header file. In some cases, no specific translation unit provides a definition of the variable. The previous behavior can be restored by specifying -fcommon.

[SjoerdMeijer]

Are there any tests remaining that check that with -fcommon, IR generation creates "common" variables, now that all these tests have been modified?

I've added a RUN line to clang/test/CodeGen/no-common.c with -fcommon that should test this.

Suggestion:

Therefore, C code that uses tentative definitions as definitions of a variable in multiple translation units will trigger multiple-definition linker errors. Generally, this occurs when the use of the extern keyword is neglected in the declaration of a variable in a header file. In some cases, no specific translation unit provides a definition of the variable. The previous behavior can be restored by specifying -fcommon.

Thanks for your suggestion. I've verbatim added this to the release note.

[SjoerdMeijer]

Friendly ping, and just checking: are we happy with this? Good to go?

[tstellar]

LGTM.

[jyknight]

Looks good modulo minor comments.

clang/test/CodeGen/microsoft-no-common-align.c

1

I think this test should specify -fcommon, since it's explicitly testing a bug we had in common support?

clang/test/CodeGenOpenCL/amdgpu-nullptr.cl

182–184

Sounds like this test is also expecting to check -fcommon behavior.

[SjoerdMeijer]

Thanks all for the reviews and help.
I will fix these things and do a last rebase/check before committing this tomorrow.

[SjoerdMeijer]

Reverted in: https://reviews.llvm.org/rG4e363563fa14

Put up for review some fixes for compiler-rt tests in: https://reviews.llvm.org/D75520

Now checking what these test-suite failures are about:

FAIL: MultiSource/Applications/JM/ldecod/ldecod.compile_time (1 of 2630)
FAIL: MultiSource/Applications/JM/lencod/lencod.compile_time (2 of 2630)
FAIL: MultiSource/Benchmarks/ASC_Sequoia/IRSmk/IRSmk.compile_time (3 of 2630)
FAIL: MultiSource/Benchmarks/DOE-ProxyApps-C/miniAMR/miniAMR.compile_time (4 of 2630)
FAIL: MultiSource/Benchmarks/Olden/bh/bh.compile_time (5 of 2630)
FAIL: MultiSource/Benchmarks/Prolangs-C/TimberWolfMC/timberwolfmc.compile_time (6 of 2630)
FAIL: MultiSource/Benchmarks/Prolangs-C/compiler/compiler.compile_time (7 of 2630)
FAIL: MultiSource/Benchmarks/Prolangs-C/loader/loader.compile_time (8 of 2630)
FAIL: MultiSource/Benchmarks/Prolangs-C/simulator/simulator.compile_time (9 of 2630)
FAIL: MultiSource/Applications/JM/ldecod/ldecod.execution_time (527 of 2630)
FAIL: MultiSource/Applications/JM/lencod/lencod.execution_time (528 of 2630)
FAIL: MultiSource/Benchmarks/ASC_Sequoia/IRSmk/IRSmk.execution_time (529 of 2630)
FAIL: MultiSource/Benchmarks/DOE-ProxyApps-C/miniAMR/miniAMR.execution_time (530 of 2630)
FAIL: MultiSource/Benchmarks/Olden/bh/bh.execution_time (531 of 2630)
FAIL: MultiSource/Benchmarks/Prolangs-C/TimberWolfMC/timberwolfmc.execution_time (532 of 2630)
FAIL: MultiSource/Benchmarks/Prolangs-C/compiler/compiler.execution_time (533 of 2630)
FAIL: MultiSource/Benchmarks/Prolangs-C/loader/loader.execution_time (534 of 2630)
FAIL: MultiSource/Benchmarks/Prolangs-C/simulator/simulator.execution_time (535 of 2630)

[SjoerdMeijer]

Ha, these test-suite apps fail with multiple definition of ... link errors, so actually require a little bit of porting! :-)
But I think I will prepare a patch that adds -fcommon to their makefiles, as I don't want to change too many things at the same time.

[MaskRay]

In D75056#1903363, @SjoerdMeijer wrote:

Ha, these test-suite apps fail with multiple definition of ... link errors, so actually require a little bit of porting! :-)
But I think I will prepare a patch that adds -fcommon to their makefiles, as I don't want to change too many things at the same time.

Adding -fcommon looks good.

[SjoerdMeijer]

Patch for the test-suite: D75557

clang/docs/ClangCommandLineReference.rst

 .. option:: -fclasspath=<arg>, --CLASSPATH <arg>, --CLASSPATH=<arg>, --classpath <arg>, --classpath=<arg>
 
 .. option:: -fcolor-diagnostics, -fno-color-diagnostics
 
 Use colors in diagnostics
 
 .. option:: -fcommon, -fno-common
 
+Place definitions of variables with no storage class and no initializer
+(tentative definitions) in a common block, instead of generating individual
+zero-initialized definitions (default -fno-common).
+
 .. option:: -fcompile-resource=<arg>, --resource <arg>, --resource=<arg>
 
 .. option:: -fconstant-cfstrings, -fno-constant-cfstrings
 
 .. option:: -fconstant-string-class=<arg>
 
 .. option:: -fconstexpr-backtrace-limit=<arg>
 

clang/docs/ReleaseNotes.rst

 The following options are deprecated and ignored. They will be removed in
 future versions of Clang.
 
 - ...
 
 Modified Compiler Flags
 -----------------------
 
+- -fno-common has been enabled as the default for all targets.  Therefore, C
+  code that uses tentative definitions as definitions of a variable in multiple
+  translation units will trigger multiple-definition linker errors.  Generally,
+  this occurs when the use of the ``extern`` keyword is neglected in the declaration
+  of a variable in a header file. In some cases, no specific translation unit
+  provides a definition of the variable. The previous behavior can be restored by
+  specifying ``-fcommon``.
 
 New Pragmas in Clang
 --------------------
 
 - ...
 
 Attribute Changes in Clang
 --------------------------

clang/include/clang/Driver/Options.td

def fcomment_block_commands : CommaJoined<["-"], "fcomment-block-commands=">, Group<f_clang_Group>, Flags<[CC1Option]>,
   MetaVarName<"<arg>">;
 def fparse_all_comments : Flag<["-"], "fparse-all-comments">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def frecord_command_line : Flag<["-"], "frecord-command-line">,
   Group<f_clang_Group>;
 def fno_record_command_line : Flag<["-"], "fno-record-command-line">,
   Group<f_clang_Group>;
 def : Flag<["-"], "frecord-gcc-switches">, Alias<frecord_command_line>;
 def : Flag<["-"], "fno-record-gcc-switches">, Alias<fno_record_command_line>;
-def fcommon : Flag<["-"], "fcommon">, Group<f_Group>;
+def fcommon : Flag<["-"], "fcommon">, Group<f_Group>,
+  Flags<[CoreOption, CC1Option]>, HelpText<"Place uninitialized global variables in a common block">;
 def fcompile_resource_EQ : Joined<["-"], "fcompile-resource=">, Group<f_Group>;
 def fcomplete_member_pointers : Flag<["-"], "fcomplete-member-pointers">, Group<f_clang_Group>,
    Flags<[CoreOption, CC1Option]>,
    HelpText<"Require member pointer base types to be complete if they would be significant under the Microsoft ABI">;
 def fno_complete_member_pointers : Flag<["-"], "fno-complete-member-pointers">, Group<f_clang_Group>,
    Flags<[CoreOption]>,
    HelpText<"Do not require member pointer base types to be complete if they would be significant under the Microsoft ABI">;
 def fcf_runtime_abi_EQ : Joined<["-"], "fcf-runtime-abi=">, Group<f_Group>,

clang/lib/Driver/ToolChains/Clang.cpp

static bool isSignedCharDefault(const llvm::Triple &Triple) {
   case llvm::Triple::riscv32:
   case llvm::Triple::riscv64:
   case llvm::Triple::systemz:
   case llvm::Triple::xcore:
     return false;
   }
 }
 
-static bool isNoCommonDefault(const llvm::Triple &Triple) {
-  switch (Triple.getArch()) {
-  default:
-    if (Triple.isOSFuchsia())
-      return true;
-    return false;
-
-  case llvm::Triple::xcore:
-  case llvm::Triple::wasm32:
-  case llvm::Triple::wasm64:
-    return true;
-  }
-}
-
 static bool hasMultipleInvocations(const llvm::Triple &Triple,
                                    const ArgList &Args) {
   // Supported only on Darwin where we invoke the compiler multiple times
   // followed by an invocation to lipo.
   if (!Triple.isOSDarwin())
     return false;
   // If more than one "-arch <arch>" is specified, we're targeting multiple
   // architectures resulting in a fat binary.
if (!SkipMaxTypeAlign) {
       std::string MaxTypeAlignStr = "-fmax-type-align=16";
       CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
     }
   }
 
   if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn, true))
     CmdArgs.push_back("-Qn");
 
-  // -fcommon is the default unless compiling kernel code or the target says so
-  bool NoCommonDefault = KernelOrKext || isNoCommonDefault(RawTriple);
-  if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
-                    !NoCommonDefault))
-    CmdArgs.push_back("-fno-common");
+  // -fno-common is the default, set -fcommon only when that flag is set.
+  if (Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common, false))
+    CmdArgs.push_back("-fcommon");
 
   // -fsigned-bitfields is default, and clang doesn't yet support
   // -funsigned-bitfields.
   if (!Args.hasFlag(options::OPT_fsigned_bitfields,
                     options::OPT_funsigned_bitfields))
     D.Diag(diag::warn_drv_clang_unsupported)
         << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
 

clang/lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   Opts.FineGrainedBitfieldAccesses =
       Args.hasFlag(OPT_ffine_grained_bitfield_accesses,
                    OPT_fno_fine_grained_bitfield_accesses, false);
   Opts.DwarfDebugFlags =
       std::string(Args.getLastArgValue(OPT_dwarf_debug_flags));
   Opts.RecordCommandLine =
       std::string(Args.getLastArgValue(OPT_record_command_line));
   Opts.MergeAllConstants = Args.hasArg(OPT_fmerge_all_constants);
-  Opts.NoCommon = Args.hasArg(OPT_fno_common);
+  Opts.NoCommon = !Args.hasArg(OPT_fcommon);
   Opts.NoInlineLineTables = Args.hasArg(OPT_gno_inline_line_tables);
   Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
   Opts.OptimizeSize = getOptimizationLevelSize(Args);
   Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
                             Args.hasArg(OPT_ffreestanding));
   if (Opts.SimplifyLibCalls)
     getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
   Opts.UnrollLoops =

clang/test/CodeGen/2008-07-21-mixed-var-fn-decl.c

 // RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s
 
 int g0, f0();
 int f1(), g1;
 
-// CHECK: @g0 = common {{(dso_local )?}}global i32 0, align 4
-// CHECK: @g1 = common {{(dso_local )?}}global i32 0, align 4
+// CHECK: @g0 = {{(dso_local )?}}global i32 0, align 4
+// CHECK: @g1 = {{(dso_local )?}}global i32 0, align 4
 

clang/test/CodeGen/2009-10-20-GlobalDebug.c

 // REQUIRES: x86-registered-target
 // RUN: %clang -target i386-apple-darwin10 -flto -S -g %s -o - | FileCheck %s
 
 // CHECK: @main.localstatic = internal global i32 0, align 4, !dbg [[L:![0-9]+]]
-// CHECK: @global = common global i32 0, align 4, !dbg [[G:![0-9]+]]
+// CHECK: @global = global i32 0, align 4, !dbg [[G:![0-9]+]]
 
 int global;
-int main() { 
+int main() {
   static int localstatic;
   return 0;
 }
 
 // CHECK: [[L]] = !DIGlobalVariableExpression(var: [[LV:.*]], expr: !DIExpression())
 // CHECK: [[LV]] = distinct !DIGlobalVariable(name: "localstatic"
 // CHECK-NOT:                                 linkageName:
 // CHECK-SAME:                                line: 9,
 // CHECK: [[G]] = !DIGlobalVariableExpression(var: [[GV:.*]], expr: !DIExpression())
 // CHECK: [[GV]] = distinct !DIGlobalVariable(name: "global"
 // CHECK-NOT:                                 linkageName:
 // CHECK-SAME:                                line: 7,

clang/test/CodeGen/aarch64-sve.c

 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint16_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint32_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint64_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVFloat16_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVFloat32_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVFloat64_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVBool_t'
 
-// CHECK: @ptr = common global <vscale x 16 x i8>* null, align 8
+// CHECK: @ptr = global <vscale x 16 x i8>* null, align 8
 // CHECK: %s8 = alloca <vscale x 16 x i8>, align 16
 // CHECK: %s16 = alloca <vscale x 8 x i16>, align 16
 // CHECK: %s32 = alloca <vscale x 4 x i32>, align 16
 // CHECK: %s64 = alloca <vscale x 2 x i64>, align 16
 // CHECK: %u8 = alloca <vscale x 16 x i8>, align 16
 // CHECK: %u16 = alloca <vscale x 8 x i16>, align 16
 // CHECK: %u32 = alloca <vscale x 4 x i32>, align 16
 // CHECK: %u64 = alloca <vscale x 2 x i64>, align 16

clang/test/CodeGen/address-space.c

 // RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm < %s | FileCheck -enable-var-scope -check-prefixes=CHECK,X86 %s
 // RUN: %clang_cc1 -triple amdgcn -emit-llvm < %s | FileCheck -enable-var-scope -check-prefixes=CHECK,AMDGCN %s
 
-// CHECK: @foo = common addrspace(1) global
+// CHECK: @foo = addrspace(1) global
 int foo __attribute__((address_space(1)));
 
-// CHECK: @ban = common addrspace(1) global
+// CHECK: @ban = addrspace(1) global
 int ban[10] __attribute__((address_space(1)));
 
-// CHECK: @a = common global
+// CHECK: @a = global
 int a __attribute__((address_space(0)));
 
 // CHECK-LABEL: define i32 @test1()
 // CHECK: load i32, i32 addrspace(1)* @foo
 int test1() { return foo; }
 
 // CHECK-LABEL: define i32 @test2(i32 %i)
 // CHECK: load i32, i32 addrspace(1)*

clang/test/CodeGen/alias.c

 // REQUIRES: arm-registered-target
 // RUN: %clang_cc1 -triple i386-pc-linux-gnu -emit-llvm -o - %s | FileCheck -check-prefix=CHECKBASIC %s
 // RUN: %clang_cc1 -triple armv7a-eabi -mfloat-abi hard -emit-llvm -o - %s | FileCheck -check-prefix=CHECKCC %s
 // RUN: %clang_cc1 -triple armv7a-eabi -mfloat-abi hard -S -o - %s | FileCheck -check-prefix=CHECKASM %s
 // RUN: %clang_cc1 -triple aarch64-linux-gnu -emit-llvm -o - %s | FileCheck -check-prefix=CHECKGLOBALS %s
 
 int g0;
-// CHECKBASIC-DAG: @g0 = common global i32 0
-// CHECKASM-DAG: .comm g0,4,4
+// CHECKBASIC-DAG: @g0 = global i32 0
+// CHECKASM-DAG:  .bss
+// CHECKASM-DAG:  .globl  g0
+// CHECKASM-DAG:  .p2align  2
+// CHECKASM-DAG:  g0:
+// CHECKASM-DAG:  .long 0
+// CHECKASM-DAG:  .size g0, 4
 __thread int TL_WITH_ALIAS;
 // CHECKBASIC-DAG: @TL_WITH_ALIAS = thread_local global i32 0, align 4
 // CHECKASM-DAG: .globl TL_WITH_ALIAS
 // CHECKASM-DAG: .size TL_WITH_ALIAS, 4
 static int bar1 = 42;
 // CHECKBASIC-DAG: @bar1 = internal global i32 42
 // CHECKASM-DAG: bar1:
 // CHECKASM-DAG: .size bar1, 4

clang/test/CodeGen/align-systemz.c

 // RUN: %clang_cc1 -triple s390x-linux-gnu -emit-llvm %s -o - | FileCheck %s
 
 // SystemZ prefers to align all global variables to two bytes.
 
 struct test {
    signed char a;
 };
 
 char c;
-// CHECK-DAG: @c = common global i8 0, align 2
+// CHECK-DAG: @c = global i8 0, align 2
 
 struct test s;
-// CHECK-DAG: @s = common global %struct.test zeroinitializer, align 2
+// CHECK-DAG: @s = global %struct.test zeroinitializer, align 2
 
 extern char ec;
 // CHECK-DAG: @ec = external global i8, align 2
 
 extern struct test es;
 // CHECK-DAG: @es = external global %struct.test, align 2
 
 // Dummy function to make sure external symbols are used.

clang/test/CodeGen/alignment.c

 // RUN: %clang_cc1 -triple i386-unknown-linux-gnu -emit-llvm %s -o - | FileCheck %s
 
 __attribute((aligned(16))) float a[128];
 union {int a[4]; __attribute((aligned(16))) float b[4];} b;
 
 // CHECK: @a = {{.*}}zeroinitializer, align 16
 // CHECK: @b = {{.*}}zeroinitializer, align 16
 
 long long int test5[1024];
-// CHECK-DAG: @test5 = common global [1024 x i64] zeroinitializer, align 8
+// CHECK-DAG: @test5 = global [1024 x i64] zeroinitializer, align 8
 
 // PR5279 - Reduced alignment on typedef.
 typedef int myint __attribute__((aligned(1)));
 
 void test1(myint *p) {
   *p = 0;
 }
 // CHECK: @test1(

clang/test/CodeGen/asm-label.c

 // RUN: %clang_cc1 -triple=i686-pc-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix=LINUX
 // RUN: %clang_cc1 -triple=i686-apple-darwin9 -emit-llvm %s -o - | FileCheck %s --check-prefix=DARWIN
 
 char *strerror(int) asm("alias");
 int x __asm("foo");
 
 int *test(void) {
   static int y __asm("bar");
   strerror(-1);
   return &y;
 }
 
 // LINUX: @bar = internal global i32 0
-// LINUX: @foo = common global i32 0
+// LINUX: @foo = global i32 0
 // LINUX: declare i8* @alias(i32)
 
 // DARWIN: @"\01bar" = internal global i32 0
-// DARWIN: @"\01foo" = common global i32 0
+// DARWIN: @"\01foo" = global i32 0
 // DARWIN: declare i8* @"\01alias"(i32)

clang/test/CodeGen/attr-weak-import.c

 int D;
 
 extern int E __attribute__((weak_import));
 int E;
 extern int E __attribute__((weak_import));
 
 // CHECK: @A = global i32
 // CHECK-NOT: @B =
-// CHECK: @C = common global i32
+// CHECK: @C = global i32
 // CHECK: @D = global i32
 // CHECK: @E = global i32
 

clang/test/CodeGen/attr-weakref2.c

 // RUN: %clang_cc1 -emit-llvm -triple i386-linux-gnu -o %t %s
 // RUN: FileCheck --input-file=%t %s
 
 // CHECK: @test1_f = extern_weak global i32
 extern int test1_f;
 static int test1_g __attribute__((weakref("test1_f")));
 int test1_h(void) {
   return test1_g;
 }
 
-// CHECK: @test2_f = common global i32 0, align 4
+// CHECK: @test2_f = global i32 0, align 4
 int test2_f;
 static int test2_g __attribute__((weakref("test2_f")));
 int test2_h(void) {
   return test2_g;
 }
 
 // CHECK: @test3_f = external global i32
 extern int test3_f;
 static int test3_g __attribute__((weakref("test3_f")));
 int test3_foo(void) {
   return test3_f;
 }
 int test3_h(void) {
   return test3_g;
 }
 
-// CHECK: @test4_f = common global i32 0, align 4
+// CHECK: @test4_f = global i32 0, align 4
 extern int test4_f;
 static int test4_g __attribute__((weakref("test4_f")));
 int test4_h(void) {
   return test4_g;
 }
 int test4_f;
 
 // CHECK: @test5_f = external global i32

clang/test/CodeGen/attributes.c

 
 // CHECK: @t18 = global i32 1, align 4
 extern int t18 __attribute__((weak_import));
 int t18 = 1;
 
 // CHECK: @t16 = extern_weak global i32
 extern int t16 __attribute__((weak_import));
 
-// CHECK: @t6 = common protected global i32 0
+// CHECK: @t6 = protected global i32 0
 int t6 __attribute__((visibility("protected")));
 
 // CHECK: @t12 = global i32 0, section "SECT"
 int t12 __attribute__((section("SECT")));
 
 // CHECK: @t9 = weak alias void (...), bitcast (void ()* @__t8 to void (...)*)
 void __t8() {}
 void t9() __attribute__((weak, alias("__t8")));

clang/test/CodeGen/blocks-windows.c

 #endif
 
 int (*g(void))(void) {
   __block int i;
   return _Block_copy(^{ ++i; return i; });
 }
 
 // CHECK-BLOCKS-IN-BLOCKS-DECL: @_NSConcreteStackBlock = external dso_local dllexport global i8*
-// CHECK-BLOCKS-IN-BLOCKS-DEFN: @_NSConcreteStackBlock = common dso_local dllexport global [5 x i32]
+// CHECK-BLOCKS-IN-BLOCKS-DEFN: @_NSConcreteStackBlock = dso_local dllexport global [5 x i32]
 // CHECK-BLOCKS-NOT-IN-BLOCKS: @_NSConcreteStackBlock = external dllimport global i8*
 // CHECK-BLOCKS-NOT-IN-BLOCKS-EXTERN: @_NSConcreteStackBlock = external dllimport global i8*
 // CHECK-BLOCKS-NOT-IN-BLOCKS-EXTERN-DLLIMPORT: @_NSConcreteStackBlock = external dllimport global i8*
 // CHECK-BLOCKS-NOT-IN-BLOCKS-DLLIMPORT: @_NSConcreteStackBlock = external dllimport global i8*
 

clang/test/CodeGen/bool-convert.c

 // RUN: %clang_cc1 -triple i686-pc-linux -emit-llvm < %s | FileCheck %s
 // All of these should uses the memory representation of _Bool
 
 // CHECK-LABEL: %struct.teststruct1 = type { i8, i8 }
-// CHECK-LABEL: @test1 = common global %struct.teststruct1
+// CHECK-LABEL: @test1 = global %struct.teststruct1
 struct teststruct1 {_Bool a, b;} test1;
 
-// CHECK-LABEL: @test2 = common global i8* null
+// CHECK-LABEL: @test2 = global i8* null
 _Bool* test2;
 
-// CHECK-LABEL: @test3 = common global [10 x i8]
+// CHECK-LABEL: @test3 = global [10 x i8]
 _Bool test3[10];
 
-// CHECK-LABEL: @test4 = common global [0 x i8]* null
+// CHECK-LABEL: @test4 = global [0 x i8]* null
 _Bool (*test4)[];
 
 // CHECK-LABEL: define void @f(i32 %x)
 void f(int x) {
   // CHECK: alloca i8, align 1
   _Bool test5;
 
   // CHECK: alloca i8, i32 %{{.*}}, align 1
   _Bool test6[x];
 }

clang/test/CodeGen/c11atomics.c

 // CHECK-DAG: %struct.ptr = type { %struct.elem* }
 
 struct elem {
     _Atomic(struct ptr) link;
 };
 // CHECK-DAG: %struct.elem = type { %struct.ptr }
 
 struct ptr object;
-// CHECK-DAG: @object = common global %struct.ptr zeroinitializer
+// CHECK-DAG: @object = global %struct.ptr zeroinitializer
 
 // CHECK-DAG: @testStructGlobal = global {{.*}} { i16 1, i16 2, i16 3, i16 4 }
 // CHECK-DAG: @testPromotedStructGlobal = global {{.*}} { %{{.*}} { i16 1, i16 2, i16 3 }, [2 x i8] zeroinitializer }
 
 
 typedef int __attribute__((vector_size(16))) vector;
 
 _Atomic(_Bool) b;

clang/test/CodeGen/cfstring-elf-cfbuild-x86_64.c

 #endif
 #endif
 
 typedef struct __CFString *CFStringRef;
 const CFStringRef string = (CFStringRef)__builtin___CFStringMakeConstantString("string");
 
 
 // CHECK-CF-IN-CF-DECL: @__CFConstantStringClassReference = external global [0 x i32]
-// CHECK-CF-IN-CF-DEFN: @__CFConstantStringClassReference = common global [32 x i64] zeroinitializer, align 16
-// CHECK-CF: @__CFConstantStringClassReference = common global [1 x i64] zeroinitializer, align 8
+// CHECK-CF-IN-CF-DEFN: @__CFConstantStringClassReference = global [32 x i64] zeroinitializer, align 16
+// CHECK-CF: @__CFConstantStringClassReference = global [1 x i64] zeroinitializer, align 8
 // CHECK-CF-EXTERN: @__CFConstantStringClassReference = external global [0 x i32]
 // CHECK-CF-EXTERN: @.str = private unnamed_addr constant [7 x i8] c"string\00", section ".rodata", align 1

clang/test/CodeGen/cfstring-windows.c

 __declspec(dllimport) long __CFConstantStringClassReference[];
 #endif
 #endif
 
 typedef struct __CFString *CFStringRef;
 const CFStringRef string = (CFStringRef)__builtin___CFStringMakeConstantString("string");
 
 // CHECK-CF-IN-CF-DECL: @__CFConstantStringClassReference = external dso_local dllexport global [0 x i32]
-// CHECK-CF-IN-CF-DEFN: @__CFConstantStringClassReference = common dso_local dllexport global [32 x i32]
+// CHECK-CF-IN-CF-DEFN: @__CFConstantStringClassReference = dso_local dllexport global [32 x i32]
 // CHECK-CF: @__CFConstantStringClassReference = external dllimport global [0 x i32]
 // CHECK-CF-EXTERN: @__CFConstantStringClassReference = external dllimport global [0 x i32]
 // CHECK-CF-EXTERN-DLLIMPORT: @__CFConstantStringClassReference = external dllimport global [0 x i32]
 // CHECK-CF-DLLIMPORT: @__CFConstantStringClassReference = external dllimport global [0 x i32]
 

clang/test/CodeGen/default-address-space.c

 // RUN: %clang_cc1 -triple amdgcn---amdgiz -emit-llvm < %s | FileCheck -check-prefixes=CHECK,COM %s
 
-// CHECK-DAG: @foo = common addrspace(1) global i32 0
+// CHECK-DAG: @foo = addrspace(1) global i32 0
 int foo;
 
-// CHECK-DAG: @ban = common addrspace(1) global [10 x i32] zeroinitializer
+// CHECK-DAG: @ban = addrspace(1) global [10 x i32] zeroinitializer
 int ban[10];
 
-// CHECK-DAG: @A = common addrspace(1) global i32* null
-// CHECK-DAG: @B = common addrspace(1) global i32* null
+// CHECK-DAG: @A = addrspace(1) global i32* null
+// CHECK-DAG: @B = addrspace(1) global i32* null
 int *A;
 int *B;
 
 // COM-LABEL: define i32 @test1()
 // CHECK: load i32, i32* addrspacecast{{[^@]+}} @foo
 int test1() { return foo; }
 
 // COM-LABEL: define i32 @test2(i32 %i)

clang/test/CodeGen/dllexport-1.c

 // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -emit-llvm -fms-extensions -Wno-ignored-attributes -Wno-extern-initializer -o - %s | FileCheck %s -check-prefix CHECK-LNX
 // RUN: %clang_cc1 -triple x86_64-pc-windows-msvc -emit-llvm -fms-extensions -o - -DMSVC %s | FileCheck %s -check-prefix CHECK-MSVC
 
 // Export const variable.
 
 // CHECK-MSVC: @x = dso_local dllexport constant i32 3, align 4
 // CHECK-LNX: @x = constant i32 3, align 4
 
 // CHECK-MSVC: @z = dso_local constant i32 4, align 4
 // CHECK-LNX: @z = constant i32 4, align 4
 
-// CHECK-MSVC: @y = common dso_local dllexport global i32 0, align 4
-// CHECK-LNX: @y = common global i32 0, align 4
+// CHECK-MSVC: @y = dso_local dllexport constant i32 0, align 4
+// CHECK-LNX: @y = constant i32 0, align 4
 
 __declspec(dllexport) int const x = 3;
 __declspec(dllexport) const int y;
 
 // expected-warning@+1 {{'extern' variable has an initializer}}
 extern int const z = 4;
 
 int main() {
   int a = x + y + z;
   return a;
 }

clang/test/CodeGen/dllexport.c

 // RUN: %clang_cc1 -triple i686-windows-msvc   -fms-extensions -emit-llvm -std=c11 -O0 -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-windows-msvc -fms-extensions -emit-llvm -std=c11 -O0 -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple i686-windows-gnu    -fms-extensions -emit-llvm -std=c11 -O0 -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-windows-gnu  -fms-extensions -emit-llvm -std=c11 -O0 -o - %s | FileCheck %s
 
 
 
 //===----------------------------------------------------------------------===//
 // Globals
 //===----------------------------------------------------------------------===//
 
 // Declarations are not exported.
 // CHECK-NOT: @ExternGlobalDecl
 __declspec(dllexport) extern int ExternGlobalDecl;
 
 // dllexport implies a definition.
-// CHECK-DAG: @GlobalDef = common dso_local dllexport global i32 0, align 4
+// CHECK-DAG: @GlobalDef = dso_local dllexport global i32 0, align 4
 __declspec(dllexport) int GlobalDef;
 
 // Export definition.
 // CHECK-DAG: @GlobalInit = dso_local dllexport global i32 1, align 4
 __declspec(dllexport) int GlobalInit = 1;
 
 // Declare, then export definition.
 // CHECK-DAG: @GlobalDeclInit = dso_local dllexport global i32 1, align 4
 __declspec(dllexport) extern int GlobalDeclInit;
 int GlobalDeclInit = 1;
 
 // Redeclarations
-// CHECK-DAG: @GlobalRedecl1 = common dso_local dllexport global i32 0, align 4
+// CHECK-DAG: @GlobalRedecl1 = dso_local dllexport global i32 0, align 4
 __declspec(dllexport) extern int GlobalRedecl1;
 __declspec(dllexport)        int GlobalRedecl1;
 
-// CHECK-DAG: @GlobalRedecl2 = common dso_local dllexport global i32 0, align 4
+// CHECK-DAG: @GlobalRedecl2 = dso_local dllexport global i32 0, align 4
 __declspec(dllexport) extern int GlobalRedecl2;
                              int GlobalRedecl2;
 
 
 
 //===----------------------------------------------------------------------===//
 // Functions
 //===----------------------------------------------------------------------===//

 
 
 
 //===----------------------------------------------------------------------===//
 // Precedence
 //===----------------------------------------------------------------------===//
 
 // dllexport takes precedence over the dllimport if both are specified.
-// CHECK-DAG: @PrecedenceGlobal1A = common dso_local dllexport global i32 0, align 4
-// CHECK-DAG: @PrecedenceGlobal1B = common dso_local dllexport global i32 0, align 4
+// CHECK-DAG: @PrecedenceGlobal1A = dso_local dllexport global i32 0, align 4
+// CHECK-DAG: @PrecedenceGlobal1B = dso_local dllexport global i32 0, align 4
 __attribute__((dllimport, dllexport))       int PrecedenceGlobal1A;
 __declspec(dllimport) __declspec(dllexport) int PrecedenceGlobal1B;
 
-// CHECK-DAG: @PrecedenceGlobal2A = common dso_local dllexport global i32 0, align 4
-// CHECK-DAG: @PrecedenceGlobal2B = common dso_local dllexport global i32 0, align 4
+// CHECK-DAG: @PrecedenceGlobal2A = dso_local dllexport global i32 0, align 4
+// CHECK-DAG: @PrecedenceGlobal2B = dso_local dllexport global i32 0, align 4
 __attribute__((dllexport, dllimport))       int PrecedenceGlobal2A;
 __declspec(dllexport) __declspec(dllimport) int PrecedenceGlobal2B;
 
 // CHECK-DAG: @PrecedenceGlobalRedecl1 = dso_local dllexport global i32 0, align 4
 __declspec(dllexport) extern int PrecedenceGlobalRedecl1;
 __declspec(dllimport)        int PrecedenceGlobalRedecl1 = 0;
 
-// CHECK-DAG: @PrecedenceGlobalRedecl2 = common dso_local dllexport global i32 0, align 4
+// CHECK-DAG: @PrecedenceGlobalRedecl2 = dso_local dllexport global i32 0, align 4
 __declspec(dllimport) extern int PrecedenceGlobalRedecl2;
 __declspec(dllexport)        int PrecedenceGlobalRedecl2;
 
 // CHECK-DAG: @PrecedenceGlobalMixed1 = dso_local dllexport global i32 1, align 4
 __attribute__((dllexport)) extern int PrecedenceGlobalMixed1;
 __declspec(dllimport)             int PrecedenceGlobalMixed1 = 1;
 
-// CHECK-DAG: @PrecedenceGlobalMixed2 = common dso_local dllexport global i32 0, align 4
+// CHECK-DAG: @PrecedenceGlobalMixed2 = dso_local dllexport global i32 0, align 4
 __attribute__((dllimport)) extern int PrecedenceGlobalMixed2;
 __declspec(dllexport)             int PrecedenceGlobalMixed2;
 
 // CHECK-DAG: define dso_local dllexport void @precedence1A()
 // CHECK-DAG: define dso_local dllexport void @precedence1B()
 void __attribute__((dllimport, dllexport))       precedence1A(void) {}
 void __declspec(dllimport) __declspec(dllexport) precedence1B(void) {}
 

clang/test/CodeGen/dllimport.c

 // and drop the dllimport with a warning.
 // MS: @GlobalRedecl3 = external dso_local global i32
 // GNU: @GlobalRedecl3 = external global i32
 __declspec(dllimport) extern int GlobalRedecl3;
                       extern int GlobalRedecl3; // dllimport ignored
 USEVAR(GlobalRedecl3)
 
 // Make sure this works even if the decl has been used before it's defined (PR20792).
-// MS: @GlobalRedecl4 = common dso_local dllexport global i32
-// GNU: @GlobalRedecl4 = common dso_local global i32
+// MS: @GlobalRedecl4 = dso_local dllexport global i32
+// GNU: @GlobalRedecl4 = dso_local global i32
 __declspec(dllimport) extern int GlobalRedecl4;
 USEVAR(GlobalRedecl4)
                       int GlobalRedecl4; // dllimport ignored
 
 // FIXME: dllimport is dropped in the AST; this should be reflected in codegen (PR02803).
 // CHECK: @GlobalRedecl5 = external dllimport global i32
 __declspec(dllimport) extern int GlobalRedecl5;
 USEVAR(GlobalRedecl5)

clang/test/CodeGen/microsoft-no-common-align.c

 // RUN: %clang_cc1 -triple x86_64-windows-msvc -emit-llvm -o - %s | FileCheck %s
 typedef float TooLargeAlignment __attribute__((__vector_size__(64)));
 typedef float NormalAlignment __attribute__((__vector_size__(4)));
 
 TooLargeAlignment TooBig;
 // CHECK: @TooBig = dso_local global <16 x float>  zeroinitializer, align 64
 NormalAlignment JustRight;
-// CHECK: @JustRight = common dso_local global <1 x float>  zeroinitializer, align 4
+// CHECK: @JustRight = dso_local global <1 x float>  zeroinitializer, align 4
 
 TooLargeAlignment *IsAPointer;
-// CHECK: @IsAPointer = common dso_local global <16 x float>* null, align 8
+// CHECK: @IsAPointer = dso_local global <16 x float>* null, align 8

clang/test/CodeGen/no-common.c

 // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-DEFAULT
-// RUN: %clang_cc1 %s -fno-common -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-NOCOMMON
+// RUN: %clang_cc1 %s -fno-common -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-DEFAULT
+// RUN: %clang_cc1 %s -fcommon -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-COMMON
 
-// CHECK-DEFAULT: @x = common {{(dso_local )?}}global
-// CHECK-NOCOMMON: @x = {{(dso_local )?}}global
+// CHECK-COMMON: @x = common {{(dso_local )?}}global
+// CHECK-DEFAULT: @x = {{(dso_local )?}}global
 int x;
 
+// CHECK-COMMON: @ABC = {{(dso_local )?}}global
 // CHECK-DEFAULT: @ABC = {{(dso_local )?}}global
-// CHECK-NOCOMMON: @ABC = {{(dso_local )?}}global
 typedef void* (*fn_t)(long a, long b, char *f, int c);
 fn_t ABC __attribute__ ((nocommon));
 
+// CHECK-COMMON: @y = common {{(dso_local )?}}global
 // CHECK-DEFAULT: @y = common {{(dso_local )?}}global
-// CHECK-NOCOMMON: @y = common {{(dso_local )?}}global
 int y __attribute__((common));

clang/test/CodeGen/pr25786.c

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple i686-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-OK
 
 void (__attribute__((regparm(3), stdcall)) *pf) ();
 void (__attribute__((regparm(2), stdcall)) foo)(int a) {
 }
-// CHECK: @pf = common global void (...)* null
+// CHECK: @pf = global void (...)* null
 // CHECK: define void @foo(i32 %a)
 
-// CHECK-OK: @pf = common global void (...)* null
+// CHECK-OK: @pf = global void (...)* null
 // CHECK-OK: define x86_stdcallcc void @foo(i32 inreg %a)

clang/test/CodeGen/pragma-pack-1.c

 // CHECK: [[struct_T2]] = type { i8, i32 }
 
 // CHECK: %struct.S3 = type { [3 x i8], i8, %struct.T3, %struct.T32 }
 // CHECK: %struct.T3 = type <{ i8, i8, i32 }>
 // CHECK: %struct.T32 = type { i8, i32 }
 // CHECK: %struct.S4 = type { [3 x i8], %struct.T4, i32 }
 // CHECK: %struct.T4 = type <{ i8, i32 }>
 
-// CHECK: @refs = common global [[struct_ref]]
-// CHECK: @ss = common global [[struct_S]]
+// CHECK: @refs = global [[struct_ref]]
+// CHECK: @ss = global [[struct_S]]

clang/test/CodeGen/pragma-weak.c

 // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -emit-llvm %s -o - -verify | FileCheck %s
 
 // CHECK: @weakvar = weak global
-// CHECK: @__weakvar_alias = common global
+// CHECK: @__weakvar_alias = global
 // CHECK: @correct_linkage = weak global
 
 
 // CHECK-DAG: @both = alias void (), void ()* @__both
 // CHECK-DAG: @both2 = alias void (), void ()* @__both2
 // CHECK-DAG: @weakvar_alias = weak alias i32, i32* @__weakvar_alias
 // CHECK-DAG: @foo = weak alias void (), void ()* @__foo
 // CHECK-DAG: @foo2 = weak alias void (), void ()* @__foo2

clang/test/CodeGen/private-extern-redef.c

 }
 
 // CHECK: @J = hidden constant
 // CHECK: @K = hidden constant
 // CHECK: @L = constant
 // CHECK: @M = hidden global
 // CHECK: @O = hidden global
 // CHECK: @I = external hidden
-// CHECK: @N = common hidden global
+// CHECK: @N = hidden global
 // CHECK-NOT: @P
 

clang/test/CodeGen/tentative-decls.c

 // RUN: %clang_cc1 -emit-llvm -w -o - %s | FileCheck %s
 
-// CHECK-DAG: @r = common {{(dso_local )?}}global [1 x {{.*}}] zeroinitializer
+// CHECK-DAG: @r = {{(dso_local )?}}global [1 x {{.*}}] zeroinitializer
 
 int r[];
 int (*a)[] = &r;
 
 struct s0;
 struct s0 x;
-// CHECK-DAG: @x = common {{(dso_local )?}}global %struct.s0 zeroinitializer
+// CHECK-DAG: @x = {{(dso_local )?}}global %struct.s0 zeroinitializer
 
 struct s0 y;
-// CHECK-DAG: @y = common {{(dso_local )?}}global %struct.s0 zeroinitializer
+// CHECK-DAG: @y = {{(dso_local )?}}global %struct.s0 zeroinitializer
 struct s0 *f0() {
   return &y;
 }
 
 struct s0 {
   int x;
 };
 
-// CHECK-DAG: @b = common {{(dso_local )?}}global [1 x {{.*}}] zeroinitializer
+// CHECK-DAG: @b = {{(dso_local )?}}global [1 x {{.*}}] zeroinitializer
 int b[];
 int *f1() {
   return b;
 }
 
 // Check that the most recent tentative definition wins.
-// CHECK-DAG: @c = common {{(dso_local )?}}global [4 x {{.*}}] zeroinitializer
+// CHECK-DAG: @c = {{(dso_local )?}}global [4 x {{.*}}] zeroinitializer
 int c[];
 int c[4];
 
 // Check that we emit static tentative definitions
 // CHECK-DAG: @c5 = internal global [1 x {{.*}}] zeroinitializer
 static int c5[];
 static int func() { return c5[0]; }
 int callfunc() { return func(); }
 

clang/test/CodeGen/tls-model.c

 }
 int __thread __attribute__((tls_model("initial-exec"))) z;
 
 // Note that unlike normal C uninitialized global variables,
 // uninitialized TLS variables do NOT have COMMON linkage.
 
 // CHECK-GD: @z1 = global i32 0
 // CHECK-GD: @f.y = internal thread_local global i32 0
-// CHECK-GD: @z2 = common global i32 0
+// CHECK-GD: @z2 = global i32 0
 // CHECK-GD: @x = thread_local global i32 0
 // CHECK-GD: @z = thread_local(initialexec) global i32 0
 
 // CHECK-LD: @z1 = global i32 0
 // CHECK-LD: @f.y = internal thread_local(localdynamic) global i32 0
-// CHECK-LD: @z2 = common global i32 0
+// CHECK-LD: @z2 = global i32 0
 // CHECK-LD: @x = thread_local(localdynamic) global i32 0
 // CHECK-LD: @z = thread_local(initialexec) global i32 0
 
 // CHECK-IE: @z1 = global i32 0
 // CHECK-IE: @f.y = internal thread_local(initialexec) global i32 0
-// CHECK-IE: @z2 = common global i32 0
+// CHECK-IE: @z2 = global i32 0
 // CHECK-IE: @x = thread_local(initialexec) global i32 0
 // CHECK-IE: @z = thread_local(initialexec) global i32 0
 
 // CHECK-LE: @z1 = global i32 0
 // CHECK-LE: @f.y = internal thread_local(localexec) global i32 0
-// CHECK-LE: @z2 = common global i32 0
+// CHECK-LE: @z2 = global i32 0
 // CHECK-LE: @x = thread_local(localexec) global i32 0
 // CHECK-LE: @z = thread_local(initialexec) global i32 0

clang/test/CodeGen/visibility.c

 // RUN: %clang_cc1 %s -triple i386-unknown-unknown -fvisibility default -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-DEFAULT
 // RUN: %clang_cc1 %s -triple i386-unknown-unknown -fvisibility protected -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-PROTECTED
 // RUN: %clang_cc1 %s -triple i386-unknown-unknown -fvisibility hidden -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-HIDDEN
 
 // CHECK-DEFAULT: @g_def = global i32 0
-// CHECK-DEFAULT: @g_com = common global i32 0
+// CHECK-DEFAULT: @g_com = global i32 0
 // CHECK-DEFAULT: @g_ext = external global i32
 // CHECK-DEFAULT: @g_deferred = internal global
 // CHECK-PROTECTED: @g_def = protected global i32 0
-// CHECK-PROTECTED: @g_com = common protected global i32 0
+// CHECK-PROTECTED: @g_com = protected global i32 0
 // CHECK-PROTECTED: @g_ext = external global i32
 // CHECK-PROTECTED: @g_deferred = internal global
 // CHECK-HIDDEN: @g_def = hidden global i32 0
-// CHECK-HIDDEN: @g_com = common hidden global i32 0
+// CHECK-HIDDEN: @g_com = hidden global i32 0
 // CHECK-HIDDEN: @g_ext = external global i32
 // CHECK-HIDDEN: @g_deferred = internal global
 int g_com;
 int g_def = 0;
 extern int g_ext;
 static char g_deferred[] = "hello";
 
 // CHECK-DEFAULT: @test4 = hidden global i32 10

clang/test/CodeGen/vlt_to_pointer.c

 // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
 
 int c[1][3*2];
-// CHECK: @{{.+}} = {{.*}} global [1 x [6 x {{i[0-9]+}}]] zeroinitializer
+// CHECK: @{{.+}} = global [1 x [6 x {{i[0-9]+}}]] zeroinitializer
 
 // CHECK-LABEL: @f
 int f(int * const m, int (**v)[*m * 2])
 {
     return &(c[0][*m]) == &((*v)[0][*m]);
     // CHECK: icmp
     // CHECK: ret i{{[0-9]+}}
 }

clang/test/CodeGen/volatile-1.c

 // RUN: %clang_cc1 -Wno-return-type -Wno-unused-value -emit-llvm %s -w -o - | FileCheck %s
 
-// CHECK: @i = common {{(dso_local )?}}global [[INT:i[0-9]+]] 0
+// CHECK: @i = {{(dso_local )?}}global [[INT:i[0-9]+]] 0
 volatile int i, j, k;
 volatile int ar[5];
 volatile char c;
-// CHECK: @ci = common {{(dso_local )?}}global [[CINT:.*]] zeroinitializer
+// CHECK: @ci = {{(dso_local )?}}global [[CINT:.*]] zeroinitializer
 volatile _Complex int ci;
 volatile struct S {
 #ifdef __cplusplus
   void operator =(volatile struct S&o) volatile;
 #endif
   int i;
 } a, b;
 

clang/test/CodeGen/weak-global.c

-// RUN: %clang_cc1 -emit-llvm < %s | grep common
-
-int i;

clang/test/CodeGen/windows-on-arm-dllimport-dllexport.c

 __declspec(dllimport) void import_function(int);
 
 void call_imported_function() {
   export_declared_function();
   return import_function(import_int);
 }
 
 // CHECK: @import_int = external dllimport global i32
-// CHECK: @export_int = common dso_local dllexport global i32 0, align 4
+// CHECK: @export_int = dso_local dllexport global i32 0, align 4
 
 // CHECK: define dso_local dllexport arm_aapcs_vfpcc void @export_implemented_function()
 
 // CHECK: declare dllimport arm_aapcs_vfpcc void @import_function(i32)
 

clang/test/CodeGenCXX/clang-sections-tentative.c

 const int cz; // not assigned a rodata section attribute
 
 #pragma clang section rodata = ".rodata.2"
 const int cx; // stays in .rodata.1
 const int cy; // .rodata.2
 
 // CHECK: @x = global i32 0, align 4 #0
 // CHECK: @y = global i32 0, align 4 #1
-// CHECK: @z = common global i32 0, align 4
+// CHECK: @z = global i32 0, align 4
 // CHECK: @cx = constant i32 0, align 4 #2
 // CHECK: @cy = constant i32 0, align 4 #3
 // CHECK: @cz = constant i32 0, align 4 #1
 
 // CHECK: attributes #0 = { "bss-section"=".bss.1" }
 // CHECK: attributes #1 = { "bss-section"=".bss.2" }
 // CHECK: attributes #2 = { "bss-section"=".bss.2" "rodata-section"=".rodata.1" }
 // CHECK: attributes #3 = { "bss-section"=".bss.2" "rodata-section"=".rodata.2" }

clang/test/CodeGenObjC/constant-string-class.m

 - (char *)customString { return cString ; }
 @end
 
 int main () {
   Foo *string = @"bla";
   return 0;
 }
 
-// CHECK-FRAGILE: @_FooClassReference = common global
+// CHECK-FRAGILE: @_FooClassReference = global
 // CHECK-NONFRAGILE: @"OBJC_CLASS_$_Object" = external global
 // CHECK-NONFRAGILE: "OBJC_CLASS_$_Foo" = global

clang/test/CodeGenObjC/tentative-cfconstantstring.m

+(NSString *)someMethod {
    return @"";
 }
 
 -(void)someMethod {
    _inlineFunction();
 }
 @end
 
-// CHECK: @__CFConstantStringClassReference = common global [24 x i32] zeroinitializer, align 16
+// CHECK: @__CFConstantStringClassReference = global [24 x i32] zeroinitializer, align 16
 // CHECK: @_unnamed_cfstring_{{.*}} = private global %struct.__NSConstantString_tag { i32* getelementptr inbounds ([24 x i32], [24 x i32]* @__CFConstantStringClassReference, i32 0, i32 0)
 
 // CHECK-LABEL: define internal void @_inlineFunction()
 // CHECK:  [[ZERO:%.*]] = load %struct._class_t*, %struct._class_t** @"OBJC_CLASSLIST_REFERENCES_
 // CHECK-NEXT:   [[ONE:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
 // CHECK-NEXT:   [[TWO:%.*]] = bitcast %struct._class_t* [[ZERO]] to i8*
 // CHECK-NEXT:   call void (i8*, i8*, [[T:%.*]]*, ...) bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, [[T:%.*]]*, ...)*)(i8* [[TWO]], i8* [[ONE]], [[T:%.*]]* bitcast (%struct.__NSConstantString_tag* @_unnamed_cfstring_{{.*}} to [[T:%.*]]*))
 // CHECK-NEXT:   ret void

clang/test/CodeGenOpenCL/address-spaces.cl

 void fl(local int *arg) {}
 
 // SPIR: i32 addrspace(2)* %arg
 // AMDGCN: i32 addrspace(4)* %arg
 void fc(constant int *arg) {}
 
 #ifdef CL20
 int i;
-// CL20-DAG: @i = common {{(dso_local )?}}addrspace(1) global i32 0
+// CL20-DAG: @i = {{(dso_local )?}}addrspace(1) global i32 0
 int *ptr;
 // CL20SPIR-DAG: @ptr = {{(common )?}}{{(dso_local )?}}addrspace(1) global i32 addrspace(4)* null
-// CL20AMDGCN-DAG: @ptr = common {{(dso_local )?}}addrspace(1) global i32* null
+// CL20AMDGCN-DAG: @ptr = {{(dso_local )?}}addrspace(1) global i32* null
 #endif
 
 // SPIR: i32* %arg
 // AMDGCN: i32 addrspace(5)* %arg
 // CL20SPIR-DAG: i32 addrspace(4)* %arg
 // CL20AMDGCN-DAG: i32* %arg
 void f(int *arg) {
 

clang/test/CodeGenOpenCL/amdgpu-nullptr.cl

 } StructTy1;
 
 typedef struct {
   constant char *p3;
   global char *p4;
   generic char *p5;
 } StructTy2;
 
-// LLVM requests global variable with common linkage to be initialized with zeroinitializer, therefore use -fno-common
-// to suppress common linkage for tentative definition.
-
 // Test 0 as initializer.
 
 // CHECK: @private_p = local_unnamed_addr addrspace(1) global i8 addrspace(5)* null, align 4
 private char *private_p = 0;
 
 // CHECK: @local_p = local_unnamed_addr addrspace(1) global i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), align 4
 local char *local_p = 0;
 
void test_func_scope_var_local(void) {
   local char *sp4 = (local char*)x;
   StructTy1 SS1 = {0, 0, 0, 0, 0};
   StructTy2 SS2 = {0, 0, 0};
 }
 
 
 // Test default initialization of pointers.
 
 // Tentative definition of global variables with non-zero initializer
 // cannot have common linkage since common linkage requires zero initialization
 // and does not have explicit section.
 
-// CHECK: @p1 = common local_unnamed_addr addrspace(1) global i8 addrspace(5)* null, align 4
+// CHECK: @p1 = local_unnamed_addr addrspace(1) global i8 addrspace(5)* null, align 4
 private char *p1;
 
-// CHECK: @p2 = weak local_unnamed_addr addrspace(1) global i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), align 4
+// CHECK: @p2 = local_unnamed_addr addrspace(1) global i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), align 4
 local char *p2;
 
-// CHECK: @p3 = common local_unnamed_addr addrspace(1) global i8 addrspace(4)* null, align 8
+// CHECK: @p3 = local_unnamed_addr addrspace(1) global i8 addrspace(4)* null, align 8
 constant char *p3;
 
-// CHECK: @p4 = common local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 8
+// CHECK: @p4 = local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 8
 global char *p4;
 
-// CHECK: @p5 = common local_unnamed_addr addrspace(1) global i8* null, align 8
+// CHECK: @p5 = local_unnamed_addr addrspace(1) global i8* null, align 8
 generic char *p5;
 
 // Test default initialization of structure.
 
-// CHECK: @S1 = weak local_unnamed_addr addrspace(1) global %struct.StructTy1 { i8 addrspace(5)* null, i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), i8 addrspace(4)* null, i8 addrspace(1)* null, i8* null }, align 8
+// CHECK: @S1 = local_unnamed_addr addrspace(1) global %struct.StructTy1 { i8 addrspace(5)* null, i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), i8 addrspace(4)* null, i8 addrspace(1)* null, i8* null }, align 8
 StructTy1 S1;
 
-// CHECK: @S2 = common local_unnamed_addr addrspace(1) global %struct.StructTy2 zeroinitializer, align 8
+// CHECK: @S2 = local_unnamed_addr addrspace(1) global %struct.StructTy2 zeroinitializer, align 8
 StructTy2 S2;
 
 // Test default initialization of array.
-// CHECK: @A1 = weak local_unnamed_addr addrspace(1) global [2 x %struct.StructTy1] [%struct.StructTy1 { i8 addrspace(5)* null, i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), i8 addrspace(4)* null, i8 addrspace(1)* null, i8* null }, %struct.StructTy1 { i8 addrspace(5)* null, i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), i8 addrspace(4)* null, i8 addrspace(1)* null, i8* null }], align 8
+// CHECK: @A1 = local_unnamed_addr addrspace(1) global [2 x %struct.StructTy1] [%struct.StructTy1 { i8 addrspace(5)* null, i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), i8 addrspace(4)* null, i8 addrspace(1)* null, i8* null }, %struct.StructTy1 { i8 addrspace(5)* null, i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), i8 addrspace(4)* null, i8 addrspace(1)* null, i8* null }], align 8
 StructTy1 A1[2];
 
-// CHECK: @A2 = common local_unnamed_addr addrspace(1) global [2 x %struct.StructTy2] zeroinitializer, align 8
+// CHECK: @A2 = local_unnamed_addr addrspace(1) global [2 x %struct.StructTy2] zeroinitializer, align 8
 StructTy2 A2[2];
 
 // Test comparison with 0.
 
 // CHECK-LABEL: cmp_private
 // CHECK: icmp eq i8 addrspace(5)* %p, null
 void cmp_private(private char* p) {
   if (p != 0)

clang/test/Driver/apple-kext-mkernel.c

 // RUN: %clang -target x86_64-apple-darwin10 -mkernel -### -fsyntax-only %s 2>&1 | FileCheck --check-prefix=CHECK-X86 %s
 // RUN: %clang -target x86_64-apple-darwin10 -mkernel -### -fsyntax-only -fbuiltin -fno-builtin -fcommon -fno-common %s 2>&1 | FileCheck --check-prefix=CHECK-X86 %s
 
 // CHECK-X86: "-disable-red-zone"
 // CHECK-X86: "-fno-builtin"
 // CHECK-X86: "-fno-rtti"
-// CHECK-X86: "-fno-common"
+// CHECK-X86-NOT: "-fcommon"
 
 // RUN: %clang -target x86_64-apple-darwin10 -mkernel -### -fsyntax-only -fbuiltin -fcommon %s 2>&1 | FileCheck --check-prefix=CHECK-X86-2 %s
 
 // CHECK-X86-2: "-disable-red-zone"
 // CHECK-X86-2-NOT: "-fno-builtin"
 // CHECK-X86-2: "-fno-rtti"
 // CHECK-X86-2-NOT: "-fno-common"
 
 // RUN: %clang -target x86_64-apple-darwin10 -arch armv7 -mkernel -mstrict-align -### -fsyntax-only %s 2>&1 | FileCheck --check-prefix=CHECK-ARM %s
 // RUN: %clang -target x86_64-apple-darwin10 -arch armv7 -mkernel -mstrict-align -### -fsyntax-only -fbuiltin -fno-builtin -fcommon -fno-common %s 2>&1 | FileCheck --check-prefix=CHECK-ARM %s
 
 // CHECK-ARM: "-target-feature" "+long-calls"
 // CHECK-ARM: "-target-feature" "+strict-align"
 // CHECK-ARM-NOT: "-target-feature" "+strict-align"
 // CHECK-ARM: "-fno-builtin"
 // CHECK-ARM: "-fno-rtti"
-// CHECK-ARM: "-fno-common"
+// CHECK-ARM-NOT: "-fcommon"
 
 // RUN: %clang -target x86_64-apple-darwin10 \
 // RUN:   -Werror -fno-builtin -fno-exceptions -fno-common -fno-rtti \
 // RUN:   -mkernel -fsyntax-only %s

clang/test/Driver/clang_f_opts.c

 // REQUIRES: clang-driver
 
 // RUN: %clang -### -S -fasm -fblocks -fbuiltin -fno-math-errno -fcommon -fpascal-strings -fno-blocks -fno-builtin -fmath-errno -fno-common -fno-pascal-strings -fblocks -fbuiltin -fmath-errno -fcommon -fpascal-strings -fsplit-stack %s 2>&1 | FileCheck -check-prefix=CHECK-OPTIONS1 %s
 // RUN: %clang -### -S -fasm -fblocks -fbuiltin -fno-math-errno -fcommon -fpascal-strings -fno-asm -fno-blocks -fno-builtin -fmath-errno -fno-common -fno-pascal-strings -fno-show-source-location -fshort-enums %s 2>&1 | FileCheck -check-prefix=CHECK-OPTIONS2 %s
 
 // CHECK-OPTIONS1: -split-stacks
 // CHECK-OPTIONS1: -fgnu-keywords
 // CHECK-OPTIONS1: -fblocks
 // CHECK-OPTIONS1: -fpascal-strings
 
 // CHECK-OPTIONS2: -fmath-errno
 // CHECK-OPTIONS2: -fno-gnu-keywords
 // CHECK-OPTIONS2: -fno-builtin
 // CHECK-OPTIONS2: -fshort-enums
-// CHECK-OPTIONS2: -fno-common
+// CHECK-OPTIONS2-NOT: -fcommon
 // CHECK-OPTIONS2: -fno-show-source-location
 
 // RUN: %clang -### -S -Wwrite-strings %s 2>&1 | FileCheck -check-prefix=WRITE-STRINGS1 %s
 // WRITE-STRINGS1: -fconst-strings
 // RUN: %clang -### -S -Wwrite-strings -Wno-write-strings %s 2>&1 | FileCheck -check-prefix=WRITE-STRINGS2 %s
 // WRITE-STRINGS2-NOT: -fconst-strings
 // RUN: %clang -### -S -Wwrite-strings -w %s 2>&1 | FileCheck -check-prefix=WRITE-STRINGS3 %s
 // WRITE-STRINGS3-NOT: -fconst-strings

clang/test/Driver/fuchsia.c

 // CHECK: "--mrelax-relocations"
 // CHECK: "-munwind-tables"
 // CHECK: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK: "-isysroot" "[[SYSROOT:[^"]+]]"
 // CHECK: "-internal-externc-isystem" "[[SYSROOT]]{{/|\\\\}}include"
 // CHECK-AARCH64: "-fsanitize=shadow-call-stack"
 // CHECK-X86_64: "-fsanitize=safe-stack"
 // CHECK: "-stack-protector" "2"
-// CHECK: "-fno-common"
+// CHECK-NOT: "-fcommon"
 // CHECK: {{.*}}ld.lld{{.*}}" "-z" "now" "-z" "rodynamic" "-z" "separate-loadable-segments"
 // CHECK: "--sysroot=[[SYSROOT]]"
 // CHECK: "-pie"
 // CHECK: "--build-id"
 // CHECK: "--hash-style=gnu"
 // CHECK: "-dynamic-linker" "ld.so.1"
 // CHECK: Scrt1.o
 // CHECK-NOT: crti.o

clang/test/Driver/no-common.c

+// RUN: %clang -target %itanium_abi_triple -### -c %s 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=DEFAULT
+// RUN: %clang -target %itanium_abi_triple -fno-common -### -c %s 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=DEFAULT
+// RUN: %clang -target %itanium_abi_triple -fno-common -fcommon -### -c %s 2>&1 | \
+// RUN:   FileCheck %s --check-prefix=COMMON
+
+// DEFAULT-NOT: "-fcommon"
+// COMMON:      "-fcommon"

clang/test/Driver/xcore-opts.c

 // RUN: %clang -target xcore %s -g -Wl,L1Arg,L2Arg -Wa,A1Arg,A2Arg -fverbose-asm -v -### -o %t.o 2>&1 | FileCheck %s
 // RUN: %clang -target xcore -x c++ %s -g -Wl,L1Arg,L2Arg -Wa,A1Arg,A2Arg -fverbose-asm -v -### -o %t.o 2>&1 | FileCheck %s
 // RUN: %clang -target xcore -x c++ %s -fexceptions -### -o %t.o 2>&1 | FileCheck -check-prefix CHECK-EXCEP %s
 // RUN: %clang -target xcore %s -g0 -### -o %t.o 2>&1 | FileCheck -check-prefix CHECK-G0 %s
 
 // CHECK: "-mframe-pointer=none"
 // CHECK: "-nostdsysteminc"
 // CHECK: "-fno-signed-char"
 // CHECK: "-fno-use-cxa-atexit"
 // CHECK-NOT: "-fcxx-exceptions"
 // CHECK-NOT: "-fexceptions"
-// CHECK: "-fno-common"
+// CHECK-NOT: "-fcommon"
 // CHECK: xcc" "-o"
 // CHECK-NOT: "-fexceptions"
 // CHECK: "-c" "-v" "-g" "-fverbose-asm" "A1Arg" "A2Arg"
 // CHECK: xcc" "-o"
 // CHECK-NOT: "-fexceptions"
 // CHECK: "-v"
 // CHECK: "L1Arg" "L2Arg"
 
 // CHECK-EXCEP: "-fno-use-cxa-atexit"
 // CHECK-EXCEP: "-fcxx-exceptions"
 // CHECK-EXCEP: "-fexceptions"
-// CHECK-EXCEP: "-fno-common"
+// CHECK-EXCEP-NOT: "-fcommon"
 // CHECK-EXCEP: xcc" "-o"
 // CHECK-EXCEP-NOT: "-fexceptions"
 // CHECK-EXCEP: xcc" "-o"
 // CHECK-EXCEP: "-fexceptions"
 
 // CHECK-G0: xcc"
 // CHECK-G0-NOT: "-g"
 // CHECK-G0: xcc"
 

clang/test/Frontend/ast-codegen.c

 // REQUIRES: x86-registered-target
 // RUN: %clang -target i386-unknown-unknown -emit-ast -o %t.ast %s
 // RUN: %clang -target i386-unknown-unknown -emit-llvm -S -o - %t.ast | FileCheck %s
 
 // CHECK: module asm "foo"
 __asm__("foo");
 
-// CHECK: @g0 = common dso_local global i32 0, align 4
+// CHECK: @g0 = dso_local global i32 0, align 4
 int g0;
 
 // CHECK: define dso_local i32 @f0()
 int f0() {
 }

clang/test/Headers/xmmintrin.c

 // RUN: %clang_cc1 %s -ffreestanding -triple x86_64-apple-macosx10.9.0 -emit-llvm -o - | FileCheck %s
 //
 // RUN: rm -rf %t
 // RUN: %clang_cc1 %s -ffreestanding -triple x86_64-apple-macosx10.9.0 -emit-llvm -o - \
 // RUN:     -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -isystem %S/Inputs/include \
 // RUN:     | FileCheck %s
 // REQUIRES: x86-registered-target
 #include <xmmintrin.h>
 
-// CHECK: @c = common global i8 0, align 16
+// CHECK: @c = global i8 0, align 16
 _MM_ALIGN16 char c;
 
 // Make sure the last step of _mm_cvtps_pi16 converts <4 x i32> to <4 x i16> by
 // checking that clang emits PACKSSDW instead of PACKSSWB.
 
 // CHECK: define i64 @test_mm_cvtps_pi16
 // CHECK: call x86_mmx @llvm.x86.mmx.packssdw
 

clang/test/PCH/chain-external-defs.c

 // RUN: FileCheck -input-file=%t -check-prefix=YB %s
 // RUN: FileCheck -input-file=%t -check-prefix=AA %s
 // RUN: FileCheck -input-file=%t -check-prefix=AB %s
 // RUN: FileCheck -input-file=%t -check-prefix=AC %s
 // RUN: FileCheck -input-file=%t -check-prefix=S %s
 
 // Z-NOT: @z
 
-// XA: @x = common global i32 0
-// XA-NOT: @x = common global i32 0
+// XA: @x = global i32 0
+// XA-NOT: @x = global i32 0
 
-// YA: @y = common global i32 0
-// YA-NOT: @y = common global i32 0
+// YA: @y = global i32 0
+// YA-NOT: @y = global i32 0
 
 // XB: @x2 = global i32 19
 // XB-NOT: @x2 = global i32 19
 int x2 = 19;
 // YB: @y2 = global i32 18
 // YB-NOT: @y2 = global i32 18
 int y2 = 18;
 
-// AA: @incomplete_array = common global [1 x i32]
-// AA-NOT: @incomplete_array = common global [1 x i32]
-// AB: @incomplete_array2 = common global [17 x i32]
-// AB-NOT: @incomplete_array2 = common global [17 x i32]
+// AA: @incomplete_array = global [1 x i32]
+// AA-NOT: @incomplete_array = global [1 x i32]
+// AB: @incomplete_array2 = global [17 x i32]
+// AB-NOT: @incomplete_array2 = global [17 x i32]
 int incomplete_array2[17];
-// AC: @incomplete_array3 = common global [1 x i32]
-// AC-NOT: @incomplete_array3 = common global [1 x i32]
+// AC: @incomplete_array3 = global [1 x i32]
+// AC-NOT: @incomplete_array3 = global [1 x i32]
 int incomplete_array3[];
 
-// S: @s = common global %struct.S
-// S-NOT: @s = common global %struct.S
+// S: @s = global %struct.S
+// S-NOT: @s = global %struct.S
 struct S {
   int x, y;
 };
 
 // Z: FINI
 // XA: FINI
 // YA: FINI
 // XB: FINI
 // YB: FINI
 // AA: FINI
 // AB: FINI
 // AC: FINI
 // S: FINI

clang/test/PCH/external-defs.c

 // REQUIRES: x86-registered-target
 // Test with pch.
 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 -emit-pch -o %t.pch %S/external-defs.h
 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 -include-pch %t.pch -emit-llvm -o %t %s
 
-// RUN: grep "@x = common global i32 0" %t | count 1
+// RUN: grep "@x = global i32 0" %t | count 1
 // RUN: not grep "@z" %t
 
 // RUN: grep "@x2 = global i32 19" %t | count 1
 int x2 = 19;
 
-// RUN: grep "@incomplete_array = common global .*1 x i32" %t | count 1
-// RUN: grep "@incomplete_array2 = common global .*17 x i32" %t | count 1
+// RUN: grep "@incomplete_array = global .*1 x i32" %t | count 1
+// RUN: grep "@incomplete_array2 = global .*17 x i32" %t | count 1
 int incomplete_array2[17];
-// RUN: grep "@incomplete_array3 = common global .*1 x i32" %t | count 1
+// RUN: grep "@incomplete_array3 = global .*1 x i32" %t | count 1
 int incomplete_array3[];
 
 struct S {
   int x, y;
 };

clang/test/PCH/tentative-defs.c

 // Test with pch.
-// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -emit-pch -o %t.pch %S/tentative-defs.h
-// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -include-pch %t.pch -verify -emit-llvm -o %t %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -fcommon -emit-pch -o %t.pch %S/tentative-defs.h
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -fcommon -include-pch %t.pch -verify -emit-llvm -o %t %s
 // REQUIRES: x86-registered-target
 
 // RUN: grep "@variable = common global i32 0" %t | count 1
 // RUN: grep "@incomplete_array = common global .*1 x i32" %t | count 1
 
 // FIXME: expected-warning@tentative-defs.h:9{{tentative}}

clang/test/Parser/pragma-visibility2.c

 // RUN: %clang_cc1 -emit-llvm -triple i386-linux-gnu -o %t %s
 // RUN: FileCheck --input-file=%t %s
 // PR10392
 
 #define push(foo) push(default)
 #pragma GCC visibility push(hidden)
 
 int v1;
-// CHECK: @v1 = common hidden global i32 0, align 4
+// CHECK: @v1 = hidden global i32 0, align 4
 
 #pragma GCC visibility pop
 
 int v2;
-// CHECK: @v2 = common global i32 0, align 4
+// CHECK: @v2 = global i32 0, align 4
 
 _Pragma("GCC visibility push(hidden)");
 
 int v3;
-// CHECK: @v3 = common hidden global i32 0, align 4
+// CHECK: @v3 = hidden global i32 0, align 4