add new option -mignore-xcoff-visibility

[DiggerLin]

Summary

In IBM compiler xlclang , there is an option -fnovisibility which suppresses visibility. For more details see: https://www.ibm.com/support/knowledgecenter/SSGH3R_16.1.0/com.ibm.xlcpp161.aix.doc/compiler_ref/opt_visibility.html.

We need to add the option -mignore-xcoff-visibility for compatibility with the IBM AIX OS (as the option is enabled by default in AIX). With this option llvm does not emit any visibility attribute to ASM or XCOFF object file.

The option only work on the AIX OS, for other non-AIX OS using the option will report an unsupported options error. For example, the file test.c:

 bash-4.2$ test.c

 __attribute__((visibility ("protected"))) int b;
 

clang   -mignore-xcoff-visibility   -target powerpc-unknown-linux    -S test.c
clang-12: error: unsupported option '-mignore-xcoff-visibility' for target 'powerpc-unknown-linux

In AIX OS:

1.1  the option -mignore-xcoff-visibility is enabled by default , if there is not -fvisibility=* and -mignore-xcoff-visibility explicitly in the clang command .

  clang -mignore-xcoff-visibility     -target powerpc-unknown-aix    -S test.c

 or
  
  clang -target powerpc-unknown-aix    -S test.c  ( the -mignore-xcoff-visibility  is enabled by default in AIX OS)

 Generate as  as :
 
  .globl  b 

1.2 if there is -fvisibility=* explicitly but not -mignore-xcoff-visibility  explicitly in the clang command.  it will generate visibility attributes.

clang  -fvisibility=default   -target powerpc-unknown-aix    -S test.c

  Generate ASM  as :
  .globl  b,protected

1.3 if there are  both  -fvisibility=* and  -mignore-xcoff-visibility  explicitly in the clang command. The option  "-mignore-xcoff-visibility" wins , it do not emit the visibility attribute. 

clang -mignore-xcoff-visibility   -fvisibility=default  -target powerpc-unknown-aix   -S test.c

 Generate ASM as :
 .globl  b
 

The option -mignore-xcoff-visibility has no effect on visibility attribute when compile with -emit-llvm option to generated LLVM IR.

[lebedev.ri]

Bad commit message - links will go dead eventually, all the relevant stuff needs to be specified in the commit message itself.

clang/docs/ClangCommandLineReference.rst

2310–2316

[DiggerLin]

add a pragma test case

[DiggerLin]

address comment

[jasonliu]

clang/docs/ClangCommandLineReference.rst

2310

We should move this option to where all the other -m options resides.

2312

clang/include/clang/Basic/LangOptions.def

300 ↗

(On Diff #291962)

nit: AIX XCOFF target

clang/include/clang/Driver/Options.td

1966

We should move this option to where the m groups belong.

clang/lib/AST/Decl.cpp

1487 ↗

(On Diff #291962)

Question: When I look for visibility in CodeGen, I could find some of the visibility settings there that does not depend on the query of existing visibility settings. For example, some of the vtable generation, which means we could still get visibility settings out from IR in some situation?
Does those visibility settings in the CodeGen matters?

clang/lib/Frontend/CompilerInvocation.cpp

2773

Question: how should -mignore-xcoff-visiblity interact with -ftype-visibility?

clang/test/Driver/ignore-xcoff-visibility.cpp

25

I don't feel like this test belongs in the Driver directory.
There is driver test needed, which is to pass in -### and specify -mignore-xcoff-visibility to see if it gets passed by the driver.
But the majority of what this test tests seems belong to CodeGen directory.

63

Do we also want to test attribute visibility on a type?
For example:

class __attribute__((__visibility__("hidden"))) TestClass {
   int foo();
   int bar();
}

[DiggerLin]

address comment

[daltenty]

llvm/include/llvm/Target/TargetMachine.h

267

This seems like it needs the corresponding comand-line option for llc added and an llc test.

[DiggerLin]

llvm/include/llvm/Target/TargetMachine.h

267

I think it will be in another separate patch.

[DiggerLin]

clang/lib/Frontend/CompilerInvocation.cpp

2773

the -ftype-visibility do not support in the clang, so there is no interact.

[jasonliu]

clang/docs/ClangCommandLineReference.rst

2310

It's rare to see an option with only the negative form. Could we rename and make it a positive form somehow?
Also we would need to move this option to where the m group belongs.

clang/test/CodeGen/aix-no-xcoff-visibility.cpp

1 ↗

(On Diff #294070)

I don't think we should call the driver directly in here.
We should have a separate driver test where we invoke clang, and we should invoke the front end clang_cc1 here.

75 ↗

(On Diff #294070)

Not sure if the IR check is really necessary, since we haven't made any IR change here. It's going to be all the same with or without the new -m option.

[jasonliu]

llvm/include/llvm/Target/TargetMachine.h

267

I would actually prefer to have that in the same patch, as that would give us a full picture. It's not a huge patch even if we combine them.

[DiggerLin]

llvm/include/llvm/Target/TargetMachine.h

267

yes, it is not huge patch, one patch for the clang with option -mno-xcoff-visibility, another patch for llc option -no-xcoff-visibility , I think it is different functionality. and I have post the https://reviews.llvm.org/D88234 "add new option -no-xcoff-visibility for llc"

[daltenty]

llvm/include/llvm/Target/TargetMachine.h

267

But the problem is this patch actually introduces the backend functionality with no test in the LLVM component itself, because the test here is Clang only. Either the patches should be merged so both components get tests in one patch or both refactored so we have one llc/LLVM patch and one clang patch.

[DiggerLin]

clang/test/CodeGen/aix-no-xcoff-visibility.cpp

75 ↗

(On Diff #294070)

IR output will not change in the new option. I think we need to check whether the IR be changed in the new option

[DiggerLin]

address comment and merger the patch https://reviews.llvm.org/D88234 into the patch

[daltenty]

clang/docs/ClangCommandLineReference.rst

2622

nit: add a space before parens

2622

I don't think the object file writing case was handled yet? This makes it sound like it is.

clang/lib/Driver/ToolChains/Clang.cpp

5246

Use Args.hasFlag instead, since this option doesn't have a value we need to check.

clang/test/CodeGen/aix-ignore-xcoff-visibility.cpp

73

This isn't being checked anymore, also probably belongs in the other file

clang/test/Driver/ignore-xcoff-visibility.cpp

3

We should check the diagnostic here

4

nit: We should constrain this to be following the cc1 invocation

[DiggerLin]

clang/docs/ClangCommandLineReference.rst

2622

yes, we do not implement the visibility of the object file in the XCoffObjectWriter.cpp

clang/lib/Driver/ToolChains/Clang.cpp

5246

we need to get the value here

D.Diag(diag::err_drv_unsupported_opt_for_target)
     << A->getAsString(Args) << TripleStr;

clang/test/CodeGen/aix-ignore-xcoff-visibility.cpp

73

thanks

[DiggerLin]

address comment

[daltenty]

llvm/lib/CodeGen/CommandFlags.cpp

339

nit: match description above

[daltenty]

clang/docs/ClangCommandLineReference.rst

2622

nit: plural. capitalization.

clang/include/clang/Driver/Options.td

2570

llvm/lib/CodeGen/CommandFlags.cpp

340

nit: capitalize XCOFF

[daltenty]

LGTM, other minor nit

[jasonliu]

llvm/include/llvm/Target/TargetOptions.h

126–129

Should the default be true for this option?
As this is an XCOFF only option, and the default for clang is true, so it would be better for llc to match as well?

[DiggerLin]

llvm/include/llvm/Target/TargetOptions.h

126–129

we can implement it in another separate patch.

[dmgreen]

Hello. I added a power-pc REQUIRES clause to the new clang test here in a15bd0bfc20c2b2955c59450a67b6e8efe89c708. Hope that looks OK.

clang/docs/ClangCommandLineReference.rst

 .. option:: -fvisibility-global-new-delete-hidden
 
 Give global C++ operator new and delete declarations hidden visibility
 
 .. option:: -fvisibility-inlines-hidden
 
 Give inline C++ member functions hidden visibility by default
 
 .. option:: -fvisibility-ms-compat
 
 Give global types 'default' visibility and global functions and variables 'hidden' visibility by default
 
 .. option:: -fvisibility=<arg>
 
 Set the default symbol visibility for all global declarations
 
 .. option:: -fwasm-exceptions
 
 Use WebAssembly style exceptions
 
 .. option:: -fwhole-program-vtables, -fno-whole-program-vtables
 
 Enables whole-program vtable optimization. Requires -flto

 .. option:: -march=<arg>
 
 .. option:: -masm=<arg>
 
 .. option:: -mbackchain, -mno-backchain
 
 Link stack frames through backchain on System Z
 
+.. option:: -mignore-xcoff-visibility
+
+Do not emit any visibility attribute for asm on AIX or give all symbols 'unspecified' visibility in XCOFF object file (XCOFF only)
+
 .. option:: -mbranches-within-32B-boundaries
 
 Align selected branches (fused, jcc, jmp) within 32-byte boundary
 
 .. option:: -mcmodel=<arg>, -mcmodel=medany (equivalent to -mcmodel=medium), -mcmodel=medlow (equivalent to -mcmodel=small)
 
 .. option:: -mconsole<arg>
 

clang/include/clang/Basic/CodeGenOptions.def

ENUM_CODEGENOPT(CompressDebugSections, llvm::DebugCompressionType, 2,
                 llvm::DebugCompressionType::None)
 CODEGENOPT(RelaxELFRelocations, 1, 0) ///< -Wa,--mrelax-relocations
 CODEGENOPT(AsmVerbose        , 1, 0) ///< -dA, -fverbose-asm.
 CODEGENOPT(PreserveAsmComments, 1, 1) ///< -dA, -fno-preserve-as-comments.
 CODEGENOPT(AssumeSaneOperatorNew , 1, 1) ///< implicit __attribute__((malloc)) operator new
 CODEGENOPT(Autolink          , 1, 1) ///< -fno-autolink
 CODEGENOPT(ObjCAutoRefCountExceptions , 1, 0) ///< Whether ARC should be EH-safe.
 CODEGENOPT(Backchain         , 1, 0) ///< -mbackchain
+CODEGENOPT(IgnoreXCOFFVisibility         , 1, 0) ///< -mignore-xcoff-visibility
 CODEGENOPT(ControlFlowGuardNoChecks  , 1, 0) ///< -cfguard-no-checks
 CODEGENOPT(ControlFlowGuard  , 1, 0) ///< -cfguard
 CODEGENOPT(CXAAtExit         , 1, 1) ///< Use __cxa_atexit for calling destructors.
 CODEGENOPT(RegisterGlobalDtorsWithAtExit, 1, 1) ///< Use atexit or __cxa_atexit to register global destructors.
 CODEGENOPT(CXXCtorDtorAliases, 1, 0) ///< Emit complete ctors/dtors as linker
                                      ///< aliases to base ctors when possible.
 CODEGENOPT(DataSections      , 1, 0) ///< Set when -fdata-sections is enabled.
 CODEGENOPT(UniqueSectionNames, 1, 1) ///< Set for -funique-section-names.

clang/include/clang/Driver/Options.td

 def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>;
 def fregister_global_dtors_with_atexit : Flag<["-"], "fregister-global-dtors-with-atexit">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use atexit or __cxa_atexit to register global destructors">;
 defm use_init_array : OptOutFFlag<"use-init-array", "", "Use .ctors/.dtors instead of .init_array/.fini_array">;
 def fno_var_tracking : Flag<["-"], "fno-var-tracking">, Group<clang_ignored_f_Group>;
 def fverbose_asm : Flag<["-"], "fverbose-asm">, Group<f_Group>,
   HelpText<"Generate verbose assembly output">;
 def dA : Flag<["-"], "dA">, Alias<fverbose_asm>;
 def fvisibility_EQ : Joined<["-"], "fvisibility=">, Group<f_Group>,
   HelpText<"Set the default symbol visibility for all global declarations">, Values<"hidden,default">;
 def fvisibility_inlines_hidden : Flag<["-"], "fvisibility-inlines-hidden">, Group<f_Group>,
   HelpText<"Give inline C++ member functions hidden visibility by default">,
   Flags<[CC1Option]>;
 def fvisibility_inlines_hidden_static_local_var :
   Flag<["-"], "fvisibility-inlines-hidden-static-local-var">, Group<f_Group>,
   HelpText<"When -fvisibility-inlines-hidden is enabled, static variables in "
            "inline C++ member functions will also be given hidden visibility "

 
 def mvx : Flag<["-"], "mvx">, Group<m_Group>;
 def mno_vx : Flag<["-"], "mno-vx">, Group<m_Group>;
 
 defm zvector : OptInFFlag<"zvector", "Enable System z vector language extension">;
 def mzvector : Flag<["-"], "mzvector">, Alias<fzvector>;
 def mno_zvector : Flag<["-"], "mno-zvector">, Alias<fno_zvector>;
 
+def mignore_xcoff_visibility : Flag<["-"], "mignore-xcoff-visibility">, Group<m_Group>,
+HelpText<"Not emit the visibility attribute for asm in AIX OS or give all symbols 'unspecified' visibility in XCOFF object file">,
+  Flags<[CC1Option]>;
 def mbackchain : Flag<["-"], "mbackchain">, Group<m_Group>, Flags<[DriverOption,CC1Option]>,
   HelpText<"Link stack frames through backchain on System Z">;
 def mno_backchain : Flag<["-"], "mno-backchain">, Group<m_Group>, Flags<[DriverOption,CC1Option]>;
 
 def mno_warn_nonportable_cfstrings : Flag<["-"], "mno-warn-nonportable-cfstrings">, Group<m_Group>;
 def mno_omit_leaf_frame_pointer : Flag<["-"], "mno-omit-leaf-frame-pointer">, Group<m_Group>;
 def momit_leaf_frame_pointer : Flag<["-"], "momit-leaf-frame-pointer">, Group<m_Group>,
   HelpText<"Omit frame pointer setup for leaf functions">;

clang/lib/CodeGen/BackendUtil.cpp

if (!MBOrErr)
           << MBOrErr.getError().message();
     else
       Options.BBSectionsFuncListBuf = std::move(*MBOrErr);
   }
 
   Options.EnableMachineFunctionSplitter = CodeGenOpts.SplitMachineFunctions;
   Options.FunctionSections = CodeGenOpts.FunctionSections;
   Options.DataSections = CodeGenOpts.DataSections;
+  Options.IgnoreXCOFFVisibility = CodeGenOpts.IgnoreXCOFFVisibility;
   Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
   Options.UniqueBasicBlockSectionNames =
       CodeGenOpts.UniqueBasicBlockSectionNames;
   Options.TLSSize = CodeGenOpts.TLSSize;
   Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
   Options.ExplicitEmulatedTLS = CodeGenOpts.ExplicitEmulatedTLS;
   Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
   Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;

clang/lib/Driver/ToolChains/Clang.cpp

if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
       assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
       CmdArgs.push_back("-fvisibility");
       CmdArgs.push_back("hidden");
       CmdArgs.push_back("-ftype-visibility");
       CmdArgs.push_back("default");
     }
   }
 
+  if (const Arg *A = Args.getLastArg(options::OPT_mignore_xcoff_visibility)) {
+    if (Triple.isOSAIX())
+      CmdArgs.push_back("-mignore-xcoff-visibility");
+    else
+      D.Diag(diag::err_drv_unsupported_opt_for_target)
+          << A->getAsString(Args) << TripleStr;
+  }
+
   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
                            options::OPT_fno_visibility_inlines_hidden_static_local_var);
   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_global_new_delete_hidden);
 
   Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
 
   // Forward -f (flag) options which we can pass directly.

clang/lib/Frontend/CompilerInvocation.cpp

if (O.matches(OPT_fpcc_struct_return) ||
       Opts.setStructReturnConvention(CodeGenOptions::SRCK_OnStack);
     } else {
       assert(O.matches(OPT_freg_struct_return) ||
              O.matches(OPT_msvr4_struct_return));
       Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs);
     }
   }
 
+  if (T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility) ||
+                      !Args.hasArg(OPT_fvisibility)))
+    Opts.IgnoreXCOFFVisibility = 1;
+
   Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
   Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option);
   bool NeedLocTracking = false;
 
   Opts.OptRecordFile = std::string(Args.getLastArgValue(OPT_opt_record_file));
   if (!Opts.OptRecordFile.empty())
     NeedLocTracking = true;
 
#include "clang/Basic/LangStandards.def"
   // The value-visibility mode defaults to "default".
   if (Arg *visOpt = Args.getLastArg(OPT_fvisibility)) {
     Opts.setValueVisibilityMode(parseVisibility(visOpt, Args, Diags));
   } else {
     Opts.setValueVisibilityMode(DefaultVisibility);
   }
 
   // The type-visibility mode defaults to the value-visibility mode.
   if (Arg *typeVisOpt = Args.getLastArg(OPT_ftype_visibility)) {
     Opts.setTypeVisibilityMode(parseVisibility(typeVisOpt, Args, Diags));
   } else {
     Opts.setTypeVisibilityMode(Opts.getValueVisibilityMode());
   }
 
   if (Args.hasArg(OPT_fvisibility_inlines_hidden))
     Opts.InlineVisibilityHidden = 1;
 

clang/test/CodeGen/aix-ignore-xcoff-visibility.cpp

+// RUN: %clang_cc1 -triple powerpc-unknown-aix -o - -x c++ -S  %s  |\
+// RUN:   FileCheck --check-prefix=IGNOREVISIBILITY-ASM %s
+
+// RUN: %clang_cc1 -triple powerpc-unknown-aix -mignore-xcoff-visibility -o - -x c++ -S %s  | \
+// RUN: FileCheck -check-prefix=IGNOREVISIBILITY-ASM %s
+
+// RUN: %clang_cc1 -triple powerpc-unknown-aix -mignore-xcoff-visibility -fvisibility default -o - -x c++ -S %s  | \
+// RUN: FileCheck -check-prefix=IGNOREVISIBILITY-ASM %s
+
+// RUN: %clang_cc1 -triple powerpc-unknown-aix -fvisibility default -o - -x c++ -S %s  | \
+// RUN: FileCheck -check-prefix=VISIBILITY-ASM %s
+
+// RUN: %clang_cc1 -triple powerpc-unknown-aix -mignore-xcoff-visibility -fvisibility default -o - -x c++ -S %s  | \
+// RUN: FileCheck -check-prefix=IGNOREVISIBILITY-ASM %s
+
+// RUN: %clang_cc1 -triple powerpc-unknown-aix -fvisibility default -o - -x c++ -S %s  | \
+// RUN: FileCheck -check-prefix=VISIBILITY-ASM %s
+
+// RUN: %clang_cc1 -triple powerpc-unknown-aix -mignore-xcoff-visibility -fvisibility default -emit-llvm -o - -x c++ %s  | \
+// RUN: FileCheck -check-prefix=VISIBILITY-IR %s
+
+// RUN: %clang_cc1 -triple powerpc-unknown-aix -fvisibility default -emit-llvm -o - -x c++ %s  | \
+// RUN: FileCheck -check-prefix=VISIBILITY-IR %s
+
+__attribute__((visibility("hidden"))) void foo_h(int *p) {
+  (*p)++;
+}
+
+__attribute__((visibility("protected"))) int b;
+
+extern __attribute__((visibility("hidden"))) void zoo_extern_h(void);
+
+void (*foo_p)(void) = zoo_extern_h;
+
+__attribute__((visibility("protected"))) void bar() {
+  foo_h(&b);
+  foo_p();
+}
+
+class TestClass {
+public:
+  __attribute__((__visibility__("hidden"))) int value() const noexcept { return 0; }
+};
+
+int main() {
+  TestClass TC;
+  return TC.value();
+}
+
+template <class T>
+class basic {
+public:
+  __attribute__((__visibility__("protected"))) int getdata() { return 1; }
+};
+
+template class basic<int>;
+
+#pragma GCC visibility push(hidden)
+int pramb;
+void prambar() {}
+#pragma GCC visibility pop
+
+// VISIBILITY-IR:    @b = protected global i32 0
+// VISIBILITY-IR:    @pramb = hidden global i32 0
+// VISIBILITY-IR:    define hidden void @_Z5foo_hPi(i32* %p)
+// VISIBILITY-IR:    declare hidden void @_Z12zoo_extern_hv()
+// VISIBILITY-IR:    define protected void @_Z3barv()
+// VISIBILITY-IR:    define linkonce_odr hidden i32 @_ZNK9TestClass5valueEv(%class.TestClass* %this)
+// VISIBILITY-IR:    define weak_odr protected i32 @_ZN5basicIiE7getdataEv(%class.basic* %this)
+// VISIBILITY-IR:    define hidden void @_Z7prambarv()
+
+// VISIBILITY-ASM: .globl  _Z5foo_hPi[DS],hidden
+// VISIBILITY-ASM: .globl  ._Z5foo_hPi,hidden
+// VISIBILITY-ASM: .globl  _Z3barv[DS],protected
+// VISIBILITY-ASM: .globl  ._Z3barv,protected
+// VISIBILITY-ASM: .weak   _ZNK9TestClass5valueEv[DS],hidden
+// VISIBILITY-ASM: .weak   ._ZNK9TestClass5valueEv,hidden
+// VISIBILITY-ASM: .weak   _ZN5basicIiE7getdataEv[DS],protected
+// VISIBILITY-ASM: .weak   ._ZN5basicIiE7getdataEv,protected
+// VISIBILITY-ASM: .globl  _Z7prambarv[DS],hidden
+// VISIBILITY-ASM: .globl  ._Z7prambarv,hidden
+// VISIBILITY-ASM: .globl  b,protected
+// VISIBILITY-ASM: .globl  pramb,hidden
+
+// IGNOREVISIBILITY-ASM: .globl  _Z5foo_hPi[DS]
+// IGNOREVISIBILITY-ASM: .globl  ._Z5foo_hPi
+// IGNOREVISIBILITY-ASM: .globl  _Z3barv[DS]
+// IGNOREVISIBILITY-ASM: .globl  ._Z3barv
+// IGNOREVISIBILITY-ASM: .weak   _ZNK9TestClass5valueEv[DS]
+// IGNOREVISIBILITY-ASM: .weak   ._ZNK9TestClass5valueEv
+// IGNOREVISIBILITY-ASM: .weak   _ZN5basicIiE7getdataEv[DS]
+// IGNOREVISIBILITY-ASM: .weak   ._ZN5basicIiE7getdataEv
+// IGNOREVISIBILITY-ASM: .globl  _Z7prambarv[DS]
+// IGNOREVISIBILITY-ASM: .globl  ._Z7prambarv
+// IGNOREVISIBILITY-ASM: .globl  b
+// IGNOREVISIBILITY-ASM: .globl  pramb

clang/test/Driver/ignore-xcoff-visibility.cpp

+// RUN: %clang -### -target powerpc-unknown-aix  -mignore-xcoff-visibility -S %s 2> %t.log
+// RUN: FileCheck -check-prefix=CHECK %s < %t.log
+ CHECK: {{.*}}clang{{.*}}" "-cc1"
+ CHECK: "-mignore-xcoff-visibility"
+
+// RUN: not %clang -mignore-xcoff-visibility -target powerpc-unknown-linux  %s  2>&1 | \
+// RUN: FileCheck -check-prefix=ERROR %s
+
+ ERROR: unsupported option '-mignore-xcoff-visibility' for target 'powerpc-unknown-linux'

llvm/include/llvm/CodeGen/CommandFlags.h

 bool getRelaxELFRelocations();
 
 bool getDataSections();
 Optional<bool> getExplicitDataSections();
 
 bool getFunctionSections();
 Optional<bool> getExplicitFunctionSections();
 
+bool getIgnoreXCOFFVisibility();
+
 std::string getBBSections();
 
 unsigned getTLSSize();
 
 bool getEmulatedTLS();
 
 bool getUniqueSectionNames();
 

llvm/include/llvm/Target/TargetMachine.h

public:
   }
 
   /// Return true if functions should be emitted into their own section,
   /// corresponding to -ffunction-sections.
   bool getFunctionSections() const {
     return Options.FunctionSections;
   }
 
+  /// Return true if visibility attribute should not be emitted in xcoff,
+  /// corresponding to -mignore-xcoff-visibility.
+  bool getIgnoreXCOFFVisibility() const {
+    return Options.IgnoreXCOFFVisibility;
+  }
+
   /// If basic blocks should be emitted into their own section,
   /// corresponding to -fbasic-block-sections.
   llvm::BasicBlockSection getBBSectionsType() const {
     return Options.BBSections;
   }
 
   /// Get the list of functions and basic block ids that need unique sections.
   const MemoryBuffer *getBBSectionsFuncListBuf() const {

llvm/include/llvm/Target/TargetOptions.h

public:
     TargetOptions()
         : UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false),
           NoTrappingFPMath(true), NoSignedZerosFPMath(false),
           HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
           GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
           EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
           DisableIntegratedAS(false), RelaxELFRelocations(false),
           FunctionSections(false), DataSections(false),
-          UniqueSectionNames(true), UniqueBasicBlockSectionNames(false),
-          TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0),
-          EmulatedTLS(false), ExplicitEmulatedTLS(false), EnableIPRA(false),
+          IgnoreXCOFFVisibility(false), UniqueSectionNames(true),
+          UniqueBasicBlockSectionNames(false), TrapUnreachable(false),
+          NoTrapAfterNoreturn(false), TLSSize(0), EmulatedTLS(false),
+          ExplicitEmulatedTLS(false), EnableIPRA(false),
           EmitStackSizeSection(false), EnableMachineOutliner(false),
           EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false),
           EmitAddrsig(false), EmitCallSiteInfo(false),
           SupportsDebugEntryValues(false), EnableDebugEntryValues(false),
           ValueTrackingVariableLocations(false), ForceDwarfFrameSection(false),
           XRayOmitFunctionIndex(false),
           FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {}
 
public:
     unsigned RelaxELFRelocations : 1;
 
     /// Emit functions into separate sections.
     unsigned FunctionSections : 1;
 
     /// Emit data into separate sections.
     unsigned DataSections : 1;
 
+    /// Do not emit visibility attribute for xcoff.
+    unsigned IgnoreXCOFFVisibility : 1;
+
     unsigned UniqueSectionNames : 1;
 
     /// Use unique names for basic block sections.
     unsigned UniqueBasicBlockSectionNames : 1;
 
     /// Emit target-specific trap instruction for 'unreachable' IR instructions.
     unsigned TrapUnreachable : 1;
 

llvm/lib/CodeGen/CommandFlags.cpp

 CGOPT(bool, StackSymbolOrdering)
 CGOPT(unsigned, OverrideStackAlignment)
 CGOPT(bool, StackRealign)
 CGOPT(std::string, TrapFuncName)
 CGOPT(bool, UseCtors)
 CGOPT(bool, RelaxELFRelocations)
 CGOPT_EXP(bool, DataSections)
 CGOPT_EXP(bool, FunctionSections)
+CGOPT(bool, IgnoreXCOFFVisibility)
 CGOPT(std::string, BBSections)
 CGOPT(unsigned, TLSSize)
 CGOPT(bool, EmulatedTLS)
 CGOPT(bool, UniqueSectionNames)
 CGOPT(bool, UniqueBasicBlockSectionNames)
 CGOPT(EABI, EABIVersion)
 CGOPT(DebuggerKind, DebuggerTuningOpt)
 CGOPT(bool, EnableStackSizeSection)
static cl::opt<bool> DataSections(
       cl::init(false));
   CGBINDOPT(DataSections);
 
   static cl::opt<bool> FunctionSections(
       "function-sections", cl::desc("Emit functions into separate sections"),
       cl::init(false));
   CGBINDOPT(FunctionSections);
 
+  static cl::opt<bool> IgnoreXCOFFVisibility(
+      "ignore-xcoff-visibility",
+      cl::desc("Not emit the visibility attribute for asm in AIX OS or give "
+               "all symbols 'unspecified' visibility in XCOFF object file"),
+      cl::init(false));
+  CGBINDOPT(IgnoreXCOFFVisibility);
+
   static cl::opt<std::string> BBSections(
       "basic-block-sections",
       cl::desc("Emit basic blocks into separate sections"),
       cl::value_desc("all | <function list (file)> | labels | none"),
       cl::init("none"));
   CGBINDOPT(BBSections);
 
   static cl::opt<unsigned> TLSSize(
TargetOptions codegen::InitTargetOptionsFromCodeGenFlags() {
   Options.NoZerosInBSS = getDontPlaceZerosInBSS();
   Options.GuaranteedTailCallOpt = getEnableGuaranteedTailCallOpt();
   Options.StackAlignmentOverride = getOverrideStackAlignment();
   Options.StackSymbolOrdering = getStackSymbolOrdering();
   Options.UseInitArray = !getUseCtors();
   Options.RelaxELFRelocations = getRelaxELFRelocations();
   Options.DataSections = getDataSections();
   Options.FunctionSections = getFunctionSections();
+  Options.IgnoreXCOFFVisibility = getIgnoreXCOFFVisibility();
   Options.BBSections = getBBSectionsMode(Options);
   Options.UniqueSectionNames = getUniqueSectionNames();
   Options.UniqueBasicBlockSectionNames = getUniqueBasicBlockSectionNames();
   Options.TLSSize = getTLSSize();
   Options.EmulatedTLS = getEmulatedTLS();
   Options.ExplicitEmulatedTLS = EmulatedTLSView->getNumOccurrences() > 0;
   Options.ExceptionModel = getExceptionModel();
   Options.EmitStackSizeSection = getEnableStackSizeSection();

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

case GlobalValue::AppendingLinkage:
     llvm_unreachable("Should never emit this");
   case GlobalValue::CommonLinkage:
     llvm_unreachable("CommonLinkage of XCOFF should not come to this path");
   }
 
   assert(LinkageAttr != MCSA_Invalid && "LinkageAttr should not MCSA_Invalid.");
 
   MCSymbolAttr VisibilityAttr = MCSA_Invalid;
+  if (!TM.getIgnoreXCOFFVisibility()) {
     switch (GV->getVisibility()) {
 
     // TODO: "exported" and "internal" Visibility needs to go here.
     case GlobalValue::DefaultVisibility:
       break;
     case GlobalValue::HiddenVisibility:
       VisibilityAttr = MAI->getHiddenVisibilityAttr();
       break;
     case GlobalValue::ProtectedVisibility:
       VisibilityAttr = MAI->getProtectedVisibilityAttr();
       break;
     }
+  }
 
   OutStreamer->emitXCOFFSymbolLinkageWithVisibility(GVSym, LinkageAttr,
                                                     VisibilityAttr);
 }
 
 void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   // Setup CurrentFnDescSym and its containing csect.
   MCSectionXCOFF *FnDescSec =

llvm/test/CodeGen/PowerPC/aix-ignore-xcoff-visibility.ll

+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec  < %s | \
+; RUN:   FileCheck --check-prefix=VISIBILITY-ASM %s
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -ignore-xcoff-visibility < %s | \
+; RUN:   FileCheck --check-prefix=IGNOREVISIBILITY-ASM %s
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec < %s | \
+; RUN:   FileCheck --check-prefix=VISIBILITY-ASM %s
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -ignore-xcoff-visibility < %s | \
+; RUN:   FileCheck --check-prefix=IGNOREVISIBILITY-ASM %s
+
+@foo_p = global void ()* @zoo_extern_h, align 4
+@b = protected global i32 0, align 4
+
+define hidden void @foo_h(i32* %p) {
+entry:
+  %p.addr = alloca i32*, align 4
+  store i32* %p, i32** %p.addr, align 4
+  %0 = load i32*, i32** %p.addr, align 4
+  %1 = load i32, i32* %0, align 4
+  %inc = add nsw i32 %1, 1
+  store i32 %inc, i32* %0, align 4
+  ret void
+}
+
+declare hidden void @zoo_extern_h()
+
+define protected void @bar() {
+entry:
+  call void @foo_h(i32* @b)
+  %0 = load void ()*, void ()** @foo_p, align 4
+  call void %0()
+  ret void
+}
+
+; VISIBILITY-ASM: .globl  foo_h[DS],hidden
+; VISIBILITY-ASM: .globl  .foo_h,hidden
+; VISIBILITY-ASM: .globl  bar[DS],protected
+; VISIBILITY-ASM: .globl  .bar,protected
+; VISIBILITY-ASM: .globl  b,protected
+
+; IGNOREVISIBILITY-ASM: .globl  foo_h[DS]
+; IGNOREVISIBILITY-ASM: .globl  .foo_h
+; IGNOREVISIBILITY-ASM: .globl  bar[DS]
+; IGNOREVISIBILITY-ASM: .globl  .bar
+; IGNOREVISIBILITY-ASM: .globl  b