[AIX] [TOC] Add -mtocdata/-mno-tocdata options on AIX

[syzaara]

Summary

This patch enables support that the XL compiler had for AIX under -qdatalocal/-qdataimported.

[MaskRay]

clang/include/clang/Basic/DiagnosticFrontendKinds.td

93 ↗

(On Diff #535088)

More conventionally, we use a driver warning in DiagnosticDriverKinds.td. Please read https://llvm.org/docs/CodingStandards.html#error-and-warning-messages

In Clang, the conventional message reads: ignoring ... because ...

clang/include/clang/Driver/Options.td

2921

Make sure AIX-specific options have TargetSpecific flag.

[alexgatea]

Updated clang doc, added assert

[alexgatea]

clang/include/clang/Basic/DiagnosticFrontendKinds.td

93 ↗

(On Diff #535088)

The problem with the driver warning approach is that the code that performs the filtering will be in CodeGen/TargetInfo.cpp, AIXTargetCodeGenInfo::setTargetAttributes and it seems to me we won't have access to Driver. In TargetInfo.cpp all of the diagnostics I see are of the FrontendKind, and I am following the same approach.

clang/include/clang/Driver/Options.td

2921

These are not meant to be target-specific to AIX. It's just that this patch only implements setTargetAttributes on AIX; on other platforms we would like these options to simply be ignored.

[MaskRay]

clang/include/clang/Driver/Options.td

2921

TOC is PowerPC specific so TargetSpecific is still applicable.

CoreOption is only needed if you want to support Windows clang-cl

[alexgatea]

Added TargetSpecific flag, updated some comments.

[MaskRay]

test/CodeGen/PowerPC/toc-data-structs-arrays.cpp

2 ↗

(On Diff #539608)

-target has been deprecated since Clang 3.4. Use --target= for new tests.

%clang and %clang++ are normally only for test/Driver. Use %clang_cc1 for codegen tests.

[alexgatea]

%clang and %clang++ are normally only for test/Driver. Use %clang_cc1 for codegen tests.

But %clang_cc1 doesn't compile c++ and one of the codegen tests involves vectors. What do you suggest for that?

[MaskRay]

In D153907#4494518, @alexgatea wrote:

%clang and %clang++ are normally only for test/Driver. Use %clang_cc1 for codegen tests.

But %clang_cc1 doesn't compile c++ and one of the codegen tests involves vectors. What do you suggest for that?

On most targets (I am not familiar with AIX), clang -c a.cc is identical to clang++ -c a.cc. clang++ just additionally links libstdc++/libc++ for the link action.
You can use -### to dump cc1 options and find the useful one for your %clang_cc1 command.

[alexgatea]

You can use -### to dump cc1 options and find the useful one for your %clang_cc1 command.

I've done this and determined which options need to be added but I don't see any precedent for this in CodeGen tests. For example no CodeGen test has -I /usr/include. It seems either way, using clang++ or adding these extra options, I will break a precedent

[MaskRay]

For non-Driver tests, use %clang %s -###

In D153907#4497602, @alexgatea wrote:

You can use -### to dump cc1 options and find the useful one for your %clang_cc1 command.

I've done this and determined which options need to be added but I don't see any precedent for this in CodeGen tests. For example no CodeGen test has -I /usr/include. It seems either way, using clang++ or adding these extra options, I will break a precedent

No CodeGen test has -I /usr/include, as we try to avoid inclusion which may be different from one machine to another.

Your test doesn't need any #include. Even if it does, try faking them, e.g. many C++ tests use namespace std { ... class initializer_list to declare std declarations they need.

lib/Driver/ToolChains/Clang.cpp

7043 ↗

(On Diff #539608)

hasArg performs claim internally.

7046 ↗

(On Diff #539608)

Args.claimAllArgs(options::OPT_mtocdata_EQ, options::OPT_mno_tocdata_EQ, ...)

7051 ↗

(On Diff #539608)

This is not needed. Making the options TargetSpecific gets the err_drv_unsupported_opt_for_target checking: D151590

test/Driver/toc-conf.c

1 ↗

(On Diff #539608)

For %clang, avoid Clang 3.4 deprecated -target . Use --target= for new tests.

[alexgatea]

Addressed most of the review suggestions (except for the include)

[alexgatea]

Rebase and fix last test case (remove include)

[cebowleratibm]

The tests appear to have gone missing on the revision of this patch I reviewed.

lib/CodeGen/Targets/PPC.cpp

277 ↗

(On Diff #540140)

There are some code paths where you don't need to evaluate the explicit tocdata/no-tocdata if it would have been redundant to the default already specified so you could be more efficient.

283 ↗

(On Diff #540140)

Is this to say that the driver sets the cc1 call to ensure no variable shows up in both lists?

[cebowleratibm]

lib/Driver/ToolChains/Clang.cpp

7136 ↗

(On Diff #541525)

unless there's a performance reason for keeping the if out of the loop, the code reads a little tighter if you push the if inside a single for loop.

I don't feel strongly but thought I'd point it out. Use your discretion.

test/CodeGen/PowerPC/toc-data-attribute.c

12 ↗

(On Diff #541525)

j is overaligned to be toc data. Are you expecting a diagnostic or for it to be quietly handled notoc-data?

I suggest splitting out the symbols that can't be toc data to another test and check for a diagnostic. If they're warnings then I suggest also checking that the IR did not apply the toc-data attribute.

[alexgatea]

lib/CodeGen/Targets/PPC.cpp

277 ↗

(On Diff #540140)

This is true about UserSpecifiedNotTOC but we need to determine UserSpecifiedTOC even if we compile with -mtocdata because we only emit diagnostics for variables which are explicitly specified as toc-data.

283 ↗

(On Diff #540140)

Yes, that's right.

lib/Driver/ToolChains/Clang.cpp

7136 ↗

(On Diff #541525)

Good point! I'll change it

test/CodeGen/PowerPC/toc-data-attribute.c

12 ↗

(On Diff #541525)

I am expecting a diagnostic. I initially added another test verifying the diagnostics for symbols that can't be toc-data; I will add it back.
The idea was to separate the test for diagnostics and the test for the toc-data attribute (and lack of). Let me know if you disagree

[hubert.reinterpretcast]

include/clang/Basic/DiagnosticFrontendKinds.td

96 ↗

(On Diff #541525)

It seems the current state of the implementation may warrant a warning when using toc-data with the large code model. The feature is only effective if TOC-based relocations are used to refer to the toc-data symbol. Has that been implemented?

[alexgatea]

Addressed latest review comments

[alexgatea]

Added diagnostic for when -mtocdata is used with -mcmodel=large

[hubert.reinterpretcast]

clang/test/Driver/tocdata-mcmodel-large-warning.c

1–8 ↗

(On Diff #541647)

Use -### for driver test to:

1. Avoid invocation of further components.
2. Observe the -cc1 options being passed.

Aside from this driver test for the warning, this patch does not seem to have driver tests for validating that the option is passed to -cc1 if and only if it should be. The missing tests should be added.

include/clang/Basic/DiagnosticDriverKinds.td

555 ↗

(On Diff #541647)

Typo fix.

lib/Driver/ToolChains/Clang.cpp

7122–7124 ↗

(On Diff #541647)

When emitting this message, the option should truly be ignored (e.g., driver should not pass the option to -cc1). Also, -mcmodel=medium is mapped by the driver to -mcmodel=large for AIX targets. The warning (and corresponding tests) should be extended to cover that.

[hubert.reinterpretcast]

clang/test/Driver/tocdata-mcmodel-large-warning.c

1–8 ↗

(On Diff #541647)

Aside from this driver test for the warning, this patch does not seem to have driver tests for validating that the option is passed to -cc1 if and only if it should be. The missing tests should be added.

Okay, I see test/Driver/toc-conf.c now. It looks like the patch was not generated with a consistent root directory?

[alexgatea]

Addressed review comments

[hubert.reinterpretcast]

clang/test/CodeGen/PowerPC/toc-data-attribute.c

2

Clang IR codegen tests do not require the LLVM target to be enabled.

clang/test/CodeGen/PowerPC/toc-data-diagnostics.c

2

Same comment.

clang/test/CodeGen/PowerPC/toc-data-structs-arrays.cpp

2

Same comment.

clang/test/Driver/toc-conf.c

2–6

No need for -S with test based on -###.

[hubert.reinterpretcast]

clang/docs/UsersManual.rst

3159

What do you mean by "global variable"? Do internal linkage variables at global scope count? Do variables in named C++ namespaces (or static data members of classes) count? How are they to be named by the options?

I guess block-scope variables with static storage duration don't count.

Whether they count or not, the effect of applying "blanket" -mtocdata upon such variables should be tested.

[cebowleratibm]

clang/test/CodeGen/PowerPC/toc-data-attribute.c

45

You expect to see j in the IR, just that it shouldn't have the toc-data attribute. Perhaps it's better to check the positive (with the #0 omitted) because the check-not may be satisfied if there is a subtle change in how j is emitted. This comment applies to multiple instances.

clang/test/Driver/toc-conf.c

15

nit: these read easier if the checks appear in the same order as the RUN steps above.

16

I assume you're checking that the -mno-tocdata property is passed on the cc1 invocation. This would read better if the cc1 were part of the match.

[hubert.reinterpretcast]

clang/docs/UsersManual.rst

3159

I guess block-scope variables with static storage duration don't count.

For the IBM XL compiler, block-scope variables with static storage duration do become toc-data when they are not part of the static pool (e.g., block-scope static in a C++ inline function).

[hubert.reinterpretcast]

clang/lib/CodeGen/Targets/PPC.cpp

275

This use of getGlobalIdentifier (having a user-interface that relies on its format) seems novel. It warrants updating the Doxygen description of the function.

I believe some discussion should be had on LLVM Discourse about this.

[alexgatea]

Addressed some review comments, moved parsing of mtocdata options to AIX.cpp

[cebowleratibm]

lib/CodeGen/Targets/PPC.cpp

274 ↗

(On Diff #541525)

@hubert.reinterpretcast and I were discussing whether or not this query is the right query to use because you're string comparing the value against a string provided by the user on the command line. I think it's probably safer to use a well-defined linkage name for the comparison and set it up such that we don't unnecessarily compute it unless the toc-data feature is opted into.

We should discuss offline and update this thread with our conclusion.

[hubert.reinterpretcast]

clang/test/CodeGen/PowerPC/toc-data-structs-arrays.cpp

21

Back-end currently does not like this. Need a change to https://github.com/llvm/llvm-project/blob/7dfe62327db81cc5ee3e29a994818370d95dc9e3/llvm/lib/Target/PowerPC/PPCISelDAGToDAG.cpp#L545.

[alexgatea]

Fixed diff discrepancy, removed asserts for structs/arrays/vectors, updated doc

[cebowleratibm]

clang/lib/CodeGen/Targets/PPC.cpp

275

I think clang::DeclarationName::getAsIdentifierInfo would be reasonable way to do it. This is a facility for printing user readable names and it makes sense to me that it would be the string a user would expect to use when specifying the command line option.

If the variable isn't a simple name then it isn't eligible for toc-data.

The more desirable way to to this would be a source-level attribute, which is something that ought to be considered in conjunction with this work, though I understand this is primarily to have an equivalent of the XL -qdatalocal= option for AIX.

[alexgatea]

Add back the missing tests

[hubert.reinterpretcast]

clang/lib/CodeGen/Targets/PPC.cpp

275

clang::DeclarationName::getAsIdentifierInfo sounds like it would not take scopes and linkage into account. It also sounds like it has additional complications around macros.

Limiting the ability to specify specific symbols to cases of external linkage using the mangled symbol names is perhaps the least controversial in terms of having something that is solid (albeit restrictive).

[lei]

clang/lib/Driver/ToolChains/AIX.cpp

531

nit: indent

[MaskRay]

clang/include/clang/Driver/Options.td

3411

If -mtocdata= is opt-in, the convention is to make just -mtocdata= CC1Option, but clear the flag for -mno-tocdata=.

clang/lib/Driver/ToolChains/AIX.cpp

536

StringSet has non-deterministic iteration order. Ensure that the behavior doesn't change :)

[syzaara]

Addressed review comments.

[syzaara]

Ping.

[amyk]

Initial review regarding some typos.

clang/docs/UsersManual.rst

3164

3174

3175

clang/include/clang/Driver/Options.td

3413

[amyk]

Here are some group review comments from today's session.

Also, can we summarize the user manual in the patch description?

clang/docs/UsersManual.rst

3156

3159

Add a description to what is done with the toc-data attribute.

3159

We should describe here:

• Add a separate paragraph to explain interface of EQ options only adding exceptions to how the global value rule for the attributes are applied to variables.
• Describe the global option descriptions first in the user manual before the EQ options

3167

Add double quotes for options.

clang/include/clang/Basic/DiagnosticDriverKinds.td

558

Just say that it's only supported for small code model.

clang/include/clang/Driver/Options.td

3409

3416

Can we move this under the option on 2957 (put positive and negative options together) and ensure the HelpTexts are updated accordingly?

clang/lib/Driver/ToolChains/AIX.cpp

504

I think this is only used once. We can probably move this down to near the place we need it, right?

508

End with period.

509

• Can the TOC data option processing be a standalone static function?
• And for the static function, please accommodate any conditions that can be turned into early exits.
• Do we even need to check options::OPT_mno_tocdata (because if none of the other three are specified, it may not have an effect)?

514

Add a comment that this checks how the global TOC attribute is set.
Or, we can update the variable name to include GlobalTOCAttribute, or TOCDataGloballyinEffect or something.

518

Add a null check for LastArg.

525

• I believe no braces are needed here.
• If this is moved into a new function, we can evaluate on whether this can be an early return.

527

Add a comment on when and how we get into the else block.

533

I think this can go away and explicitly check if the option type matches the TocDataInEffect.

536

Add a comment to specify that we're going through the list of exceptions to the globals.
Also, can we add more comments throughout this function?

539

• We may want to rename this so its more clearer.
• Possibly remove the enums?
• remove ExplicitOptionDefaultOverride.
• Check if the option matches TocDataInEffect?

543

• Add a comment elaborating on all of this.
• Consider moving the for loops into the if/else so it will be clearer and so we are not checking for every value.
• Maybe we can change this to: Does the option type match the global value in effect, and then do the opposite?
  • Get rid of the override, and if it doesn't match the default, then we insert (to maintain a set of exceptions to the default)

[amyk]

One last comment from the group code review.

clang/lib/Driver/ToolChains/AIX.cpp

566

What is inside the if/else are similar. If they're the same, maybe we can set a variable inside the if/else and then move the other lines out of the if/else.

[hubert.reinterpretcast]

clang/docs/UsersManual.rst

3156

@syzaara, I see the comment has been addressed but it is not marked as "done". The author is responsible for marking comments as "done" in Phabricator. Please mark all comments that you believe have been addressed as "done" so that other parties know if the comment is still pending action.

3161

The "toc-data attribute" is an implementation detail. The user-facing documentation should not talk about it.

3173

Please document the conditions for a variable to be "suitable".

3178

The use of "all" is incorrect. Please qualify with "suitable" (and address this issue elsewhere in the text where applicable).

[syzaara]

clang/include/clang/Driver/Options.td

3411

Our situation with these options is a bit more complicated because -mno-tocdata= is not just removing the entries that were specified by -mtocdata=
For example if we have:

-mtocdata=X -mno-tocdata=X -mtocdata=Y,Z,S

Then we could potentially just forward to CC1:

-mtocdata=Y,Z,S

Rather than what we currently forward:

-mno-tocdata -mtocdata=Y,Z,S

However, if we have

-mtocdata -mno-tocdata=Y,Z,S

This means all suitable variables by default will become toc-data aside from the exceptions in -mno-tocdata=Y,Z,S
and we would need to forward both these options.

So the way we handle it is by passing to CC1 either

-mtocdata -mno-tocdata=

or

-mno-tocdata -mtocdata=

which is the current default setting along with the exceptions that need to be applied to that default setting.

[DiggerLin]

clang/include/clang/Driver/Options.td

3405

do we need CLOption, DXCOption here ? these two option is for Window OS. ?

clang/docs/UsersManual.rst

.. option:: -fcomment-block-commands=[commands]
   custom commands ``\foo`` and ``\bar``.
 
   It is also possible to use ``-fcomment-block-commands`` several times; e.g.
   ``-fcomment-block-commands=foo -fcomment-block-commands=bar`` does the same
   as above.
 
 .. _c:
 
+Mark TOC / No TOC Data (AIX-specific)
+-------------------------------------------
+
+When -mtocdata is specified, all external linkage variables and variables with
+static storage duration, including static data members of classes and
+block-scope static variables will be marked with the toc-data attribute.
+Alternatively, the user can specify a comma separated list of external linkage
+variables using -mtocdata=<list> using the mangled names.
+
+The toc-data attribute results in the variable being place directly in the TOC,
+rather than having the address of the variable being placed in the TOC. This
+results in having one less load when loading the data from the TOC.
+The effects of the toc-data attribute only take effect on AIX when the symbol
+is independently-generated (e.g. not placed in a pool).
+
+The default is -mno-tocdata and a user can then use -mtocdata=<list> to add
+which variables will be an exception to -mno-tocdata. Alternatively, a user
+may specify -mtocdata to mark all suitable variables with toc-data and specify
+-mno-tocdata=<list> to add which variables will be an exception to -mtocdata.
+
+.. option:: -mtocdata
+
+  Mark all external linkage variables and variables with static storage duration
+  that are not explicitly specified with -mno-tocdata= as toc-data.
+
+.. option:: -mno-tocdata
+
+  This is the default behaviour.
+  Only variables explicitly specified with -mtocdata= will be treated as toc-data.
+
+.. option:: -mtocdata=<list>
+
+  Mark the specified external linkage variables as "toc-data" if valid, or emit
+  diagnostics otherwise.
+
+.. option:: -mno-tocdata=<list>
+
+  Mark the specified external linkage variables are exceptions to toc-data.
+
 C Language Features
 ===================
 
 The support for standard C in clang is feature-complete except for the
 C99 floating-point pragmas.
 
 Extensions supported by clang
 -----------------------------

clang/include/clang/Basic/CodeGenOptions.h

public:
   /// Set of XRay instrumentation kinds to emit.
   XRayInstrSet XRayInstrumentationBundle;
 
   std::vector<std::string> DefaultFunctionAttrs;
 
   /// List of dynamic shared object files to be loaded as pass plugins.
   std::vector<std::string> PassPlugins;
 
+  /// List of global variables explicitly specified by the user as toc-data.
+  std::vector<std::string> TocDataVarsUserSpecified;
+
+  /// List of global variables that over-ride the toc-data default.
+  std::vector<std::string> NoTocDataVars;
+
+  /// Flag for all global variables to be treated as toc-data.
+  bool AllTocData;
+
   /// Path to allowlist file specifying which objects
   /// (files, functions) should exclusively be instrumented
   /// by sanitizer coverage pass.
   std::vector<std::string> SanitizeCoverageAllowlistFiles;
 
   /// The guard style used for stack protector to get a initial value, this
   /// value usually be gotten from TLS or get from __stack_chk_guard, or some
   /// other styles we may implement in the future.

clang/include/clang/Basic/DiagnosticDriverKinds.td

def warn_target_unsupported_compact_branches : Warning<
   " support it">, InGroup<UnsupportedCB>;
 def warn_target_unsupported_extension : Warning<
   "ignoring extension '%0' because the '%1' architecture does not support it">,
    InGroup<InvalidCommandLineArgument>;
 def warn_drv_unsupported_gpopt : Warning<
   "ignoring '-mgpopt' option as it cannot be used with %select{|the implicit"
   " usage of }0-mabicalls">,
   InGroup<UnsupportedGPOpt>;
+def warn_drv_unsupported_tocdata: Warning<
+  "ignoring '-mtocdata' as it is only supported for -mcmodel=small">,
+  InGroup<OptionIgnored>;
+def warn_toc_unsupported_type : Warning<"The -m[no-]tocdata option is ignored "
+  "for %0 because %1.">, InGroup<BackendWarningAttributes>;
 def warn_drv_unsupported_sdata : Warning<
   "ignoring '-msmall-data-limit=' with -mcmodel=large for -fpic or RV64">,
   InGroup<OptionIgnored>;
 def warn_drv_unsupported_longcalls : Warning<
   "ignoring '-mlong-calls' option as it is not currently supported with "
   "%select{|the implicit usage of }0-mabicalls">,
   InGroup<OptionIgnored>;
 def warn_drv_unsupported_pic_with_mabicalls : Warning<

clang/include/clang/Driver/Options.td

 def fno_pch_validate_input_files_content:
   Flag <["-"], "fno_pch-validate-input-files-content">,
   Group<f_Group>, Flags<[NoXarchOption]>;
 defm pch_instantiate_templates : BoolFOption<"pch-instantiate-templates",
   LangOpts<"PCHInstantiateTemplates">, DefaultFalse,
   PosFlag<SetTrue, [], [ClangOption], "Instantiate templates already while building a PCH">,
   NegFlag<SetFalse>, BothFlags<[], [ClangOption, CC1Option, CLOption]
           >>;
 defm pch_codegen: OptInCC1FFlag<"pch-codegen", "Generate ", "Do not generate ",
   "code for uses of this PCH that assumes an explicit object file will be built for the PCH">;
 defm pch_debuginfo: OptInCC1FFlag<"pch-debuginfo", "Generate ", "Do not generate ",
   "debug info for types in an object file built from this PCH and do not generate them elsewhere">;
 
 def fimplicit_module_maps : Flag <["-"], "fimplicit-module-maps">, Group<f_Group>,
   Flags<[NoXarchOption]>,
   Visibility<[ClangOption, CC1Option, CLOption]>,
   HelpText<"Implicitly search the file system for module map files.">,

 def fplugin_arg : Joined<["-"], "fplugin-arg-">,
   MetaVarName<"<name>-<arg>">,
   HelpText<"Pass <arg> to plugin <name>">;
 def fpass_plugin_EQ : Joined<["-"], "fpass-plugin=">,
   Group<f_Group>, Visibility<[ClangOption, CC1Option, FlangOption, FC1Option]>,
   MetaVarName<"<dsopath>">,
   HelpText<"Load pass plugin from a dynamic shared object file (only with new pass manager).">,
   MarshallingInfoStringVector<CodeGenOpts<"PassPlugins">>;
+def mtocdata : Flag<["-"], "mtocdata">,
+  Visibility<[ClangOption, CLOption, DXCOption, CC1Option]>,
+  Flags<[TargetSpecific]>,
+  HelpText<"All suitable variables will be treated as toc-data">,
+  MarshallingInfoFlag<CodeGenOpts<"AllTocData">>;
+def mno_tocdata : Flag<["-"], "mno-tocdata">,
+  Visibility<[ClangOption, CLOption, DXCOption, CC1Option]>,
+  Flags<[TargetSpecific]>,
+  HelpText<"This is the default. Variables are treated as not having toc-data attribute."
+           "Only variables specified explicitly in -mtocdata=<> will be treated as toc-data">;
+def mtocdata_EQ : CommaJoined<["-"], "mtocdata=">,
+  Visibility<[ClangOption, CLOption, DXCOption, CC1Option]>,
+  Flags<[TargetSpecific]>,
+  HelpText<"Specifies a list of variables to treat as having toc-data attribute">,
+  MarshallingInfoStringVector<CodeGenOpts<"TocDataVarsUserSpecified">>;
+def mno_tocdata_EQ : CommaJoined<["-"], "mno-tocdata=">,
+  Visibility<[ClangOption, CLOption, DXCOption, CC1Option]>,
+  Flags<[TargetSpecific]>,
+  HelpText<"Specifies a list of variables to be exempt from having the toc-data attribute">,
+  MarshallingInfoStringVector<CodeGenOpts<"NoTocDataVars">>;
 defm preserve_as_comments : BoolFOption<"preserve-as-comments",
   CodeGenOpts<"PreserveAsmComments">, DefaultTrue,
   NegFlag<SetFalse, [], [ClangOption, CC1Option],
           "Do not preserve comments in inline assembly">,
   PosFlag<SetTrue>>;
 def framework : Separate<["-"], "framework">, Flags<[LinkerInput]>;
 def frandom_seed_EQ : Joined<["-"], "frandom-seed=">, Group<clang_ignored_f_Group>;
 def freg_struct_return : Flag<["-"], "freg-struct-return">, Group<f_Group>,

clang/lib/CodeGen/CGDecl.cpp

llvm::Constant *CodeGenModule::getOrCreateStaticVarDecl(
 
   if (supportsCOMDAT() && GV->isWeakForLinker())
     GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
 
   if (D.getTLSKind())
     setTLSMode(GV, D);
 
   setGVProperties(GV, &D);
+  getTargetCodeGenInfo().setTargetAttributes(cast<Decl>(&D), GV, *this);
 
   // Make sure the result is of the correct type.
   LangAS ExpectedAS = Ty.getAddressSpace();
   llvm::Constant *Addr = GV;
   if (AS != ExpectedAS) {
     Addr = getTargetCodeGenInfo().performAddrSpaceCast(
         *this, GV, AS, ExpectedAS,
         llvm::PointerType::get(getLLVMContext(),

clang/lib/CodeGen/Targets/PPC.cpp

 //===- PPC.cpp ------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ABIInfoImpl.h"
 #include "TargetInfo.h"
+#include "clang/Driver/DriverDiagnostic.h"
 
 using namespace clang;
 using namespace clang::CodeGen;
 
 static Address complexTempStructure(CodeGenFunction &CGF, Address VAListAddr,
                                     QualType Ty, CharUnits SlotSize,
                                     CharUnits EltSize, const ComplexType *CTy) {
   Address Addr =
AIXTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool Is64Bit)
       : TargetCodeGenInfo(std::make_unique<AIXABIInfo>(CGT, Is64Bit)),
         Is64Bit(Is64Bit) {}
   int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override {
     return 1; // r1 is the dedicated stack pointer
   }
 
   bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
                                llvm::Value *Address) const override;
+
+  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
+                           CodeGen::CodeGenModule &M) const override;
 };
 } // namespace
 
 // Return true if the ABI requires Ty to be passed sign- or zero-
 // extended to 32/64 bits.
 bool AIXABIInfo::isPromotableTypeForABI(QualType Ty) const {
   // Treat an enum type as its underlying type.
   if (const EnumType *EnumTy = Ty->getAs<EnumType>())
return emitVoidPtrVAArg(CGF, VAListAddr, Ty, /*Indirect*/ false, TypeInfo,
                           SlotSize, /*AllowHigher*/ true);
 }
 
 bool AIXTargetCodeGenInfo::initDwarfEHRegSizeTable(
     CodeGen::CodeGenFunction &CGF, llvm::Value *Address) const {
   return PPC_initDwarfEHRegSizeTable(CGF, Address, Is64Bit, /*IsAIX*/ true);
 }
 
+void AIXTargetCodeGenInfo::setTargetAttributes(
+    const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M) const {
+  if (auto *GVar = dyn_cast<llvm::GlobalVariable>(GV)) {
+    auto GVId = M.getMangledName(dyn_cast<NamedDecl>(D));
+
+    // Is this a global variable specified by the user as toc-data?
+    bool UserSpecifiedTOC =
+        llvm::binary_search(M.getCodeGenOpts().TocDataVarsUserSpecified, GVId);
+    bool UserSpecifiedNoTOC =
+        llvm::binary_search(M.getCodeGenOpts().NoTocDataVars, GVId);
+
+    if (UserSpecifiedTOC ||
+        (M.getCodeGenOpts().AllTocData &&
+         (!UserSpecifiedNoTOC || !GV->hasExternalLinkage()))) {
+      const unsigned long PointerSize =
+          GV->getParent()->getDataLayout().getPointerSizeInBits() / 8;
+      ASTContext &Context = D->getASTContext();
+      auto *VarD = dyn_cast<VarDecl>(D);
+      assert(VarD && "Invalid declaration of global variable.");
+
+      unsigned Alignment = Context.toBits(Context.getDeclAlign(D)) / 8;
+      const auto *Ty = VarD->getType().getTypePtr();
+
+      if (!Ty || Ty->isIncompleteType()) {
+        if (UserSpecifiedTOC)
+          M.getDiags().Report(D->getLocation(), diag::warn_toc_unsupported_type)
+              << GVId << "of incomplete type";
+      } else if (VarD->getTLSKind() != VarDecl::TLS_None) {
+        if (UserSpecifiedTOC)
+          M.getDiags().Report(D->getLocation(), diag::warn_toc_unsupported_type)
+              << GVId << "of thread local storage model";
+      } else if (PointerSize < Context.getTypeInfo(VarD->getType()).Width / 8) {
+        if (UserSpecifiedTOC)
+          M.getDiags().Report(D->getLocation(), diag::warn_toc_unsupported_type)
+              << GVId << "variable is larger than a pointer";
+      } else if (PointerSize < Alignment) {
+        if (UserSpecifiedTOC)
+          M.getDiags().Report(D->getLocation(), diag::warn_toc_unsupported_type)
+              << GVId << "variable is aligned wider than a pointer";
+      } else if (D->hasAttr<SectionAttr>()) {
+        if (UserSpecifiedTOC)
+          M.getDiags().Report(D->getLocation(), diag::warn_toc_unsupported_type)
+              << GVId << "of a section attribute";
+      } else if (UserSpecifiedTOC && !GV->hasExternalLinkage()) {
+        M.getDiags().Report(D->getLocation(), diag::warn_toc_unsupported_type)
+            << GVId << "variable does not have external linkage";
+      } else {
+        if (UserSpecifiedNoTOC && !GV->hasExternalLinkage())
+          M.getDiags().Report(D->getLocation(), diag::warn_toc_unsupported_type)
+              << GVId << "variable does not have external linkage";
+
+        GVar->addAttribute("toc-data");
+      }
+    }
+  }
+}
+
 // PowerPC-32
 namespace {
 /// PPC32_SVR4_ABIInfo - The 32-bit PowerPC ELF (SVR4) ABI information.
 class PPC32_SVR4_ABIInfo : public DefaultABIInfo {
   bool IsSoftFloatABI;
   bool IsRetSmallStructInRegABI;
 
   CharUnits getParamTypeAlignment(QualType Ty) const;

clang/lib/Driver/ToolChains/AIX.cpp

if (Args.hasArg(options::OPT_fexperimental_library))
       CmdArgs.push_back("-lc++experimental");
     CmdArgs.push_back("-lc++abi");
     return;
   }
 
   llvm_unreachable("Unexpected C++ library type; only libc++ is supported.");
 }
 
+// This function processes all the mtocdata options to build the final
+// simplified tocdata options to pass to CC1.
+static void addTocDataOptions(const llvm::opt::ArgList &Args,
+                              llvm::opt::ArgStringList &CC1Args,
+                              const Driver &D) {
+
+  // Check the global toc-data setting. The default is -mno-tocdata.
+  // To enable toc-data globally, -mtocdata must be specified.
+  // Additionally, it must be last to take effect.
+  const bool TOCDataGloballyinEffect = [&Args]() {
+    if (!Args.hasArg(options::OPT_mtocdata))
+      return false;
+
+    const Arg *LastArg =
+        Args.getLastArg(options::OPT_mtocdata, options::OPT_mno_tocdata);
+    return LastArg->getOption().matches(options::OPT_mtocdata);
+  }();
+
+
+  // Currently only supported for small code model.
+  if (TOCDataGloballyinEffect &&
+      (Args.getLastArgValue(options::OPT_mcmodel_EQ).equals("large") ||
+       Args.getLastArgValue(options::OPT_mcmodel_EQ).equals("medium"))) {
+    D.Diag(clang::diag::warn_drv_unsupported_tocdata);
+    return;
+  }
+
+  enum TOCDataSetting {
+    AddressInTOC = 0, // Address of the symbol stored in the TOC.
+    DataInTOC = 1     // Symbol defined in the TOC.
+  };
+
+  const TOCDataSetting DefaultTocDataSetting =
+      TOCDataGloballyinEffect ? DataInTOC : AddressInTOC;
+
+  // Process the list of variables in the explicitly specified options
+  // -mtocdata=<> and -mno-tocdata=<> to see which variables are opposite to
+  // the global setting of tocdata in TOCDataGloballyinEffect.
+  // Those that have the opposite setting to TOCDataGloballyinEffect, are added
+  // to ExplicitlySpecifiedGlobals.
+  llvm::StringSet<> ExplicitlySpecifiedGlobals;
+  for (const auto Arg : Args.filtered(options::OPT_mtocdata_EQ,
+                                      options::OPT_mno_tocdata_EQ)) {
+    TOCDataSetting ArgTocDataSetting =
+        Arg->getOption().matches(options::OPT_mtocdata_EQ) ? DataInTOC
+                                                           : AddressInTOC;
+
+    if (ArgTocDataSetting != DefaultTocDataSetting)
+      for (const char *Val : Arg->getValues())
+        ExplicitlySpecifiedGlobals.insert(Val);
+    else
+      for (const char *Val : Arg->getValues())
+        ExplicitlySpecifiedGlobals.erase(Val);
+  }
+
+  const bool HasExplicitValues = !ExplicitlySpecifiedGlobals.empty();
+
+  auto buildExceptionList = [](const llvm::StringSet<> &ExplicitValues,
+                               const char *OptionSpelling) -> std::string {
+    std::string Option(OptionSpelling);
+    bool IsFirst = true;
+    for (const auto &E : ExplicitValues) {
+      if (!IsFirst)
+        Option += ",";
+
+      IsFirst = false;
+      Option += E.first();
+    }
+    return Option;
+  };
+
+  // Pass the final tocdata options to CC1 consisting of the default
+  // tocdata option (-mtocdata/-mno-tocdata) along with the list 
+  // option (-mno-tocdata=/-mtocdata=) if there are any explicitly specified
+  // variables which would be exceptions to the default setting.
+  const char *TocDataGlobalOption = TOCDataGloballyinEffect ? "-mtocdata" : "-mno-tocdata";
+  const char *TocDataListOption = TOCDataGloballyinEffect ? "-mno-tocdata=" : "-mtocdata=";
+  CC1Args.push_back(TocDataGlobalOption);
+  if (HasExplicitValues)
+    CC1Args.push_back(Args.MakeArgString(llvm::Twine(buildExceptionList(
+            ExplicitlySpecifiedGlobals, TocDataListOption))));
+}
+
 void AIX::addClangTargetOptions(
     const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CC1Args,
     Action::OffloadKind DeviceOffloadingKind) const {
   Args.AddLastArg(CC1Args, options::OPT_mignore_xcoff_visibility);
   Args.AddLastArg(CC1Args, options::OPT_mdefault_visibility_export_mapping_EQ);
   Args.addOptInFlag(CC1Args, options::OPT_mxcoff_roptr, options::OPT_mno_xcoff_roptr);
 
+  // Forward last mtocdata/mno_tocdata options to -cc1
+  if (Args.hasArg(options::OPT_mtocdata_EQ, options::OPT_mno_tocdata_EQ,
+                  options::OPT_mtocdata))
+    addTocDataOptions(Args, CC1Args, getDriver());
+
   if (Args.hasFlag(options::OPT_fxl_pragma_pack,
                    options::OPT_fno_xl_pragma_pack, true))
     CC1Args.push_back("-fxl-pragma-pack");
 }
 
 void AIX::addProfileRTLibs(const llvm::opt::ArgList &Args,
                            llvm::opt::ArgStringList &CmdArgs) const {
   // Add linker option -u__llvm_profile_runtime to cause runtime
   // initialization to occur.
   if (needsProfileRT(Args))
     CmdArgs.push_back(Args.MakeArgString(
         Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
   ToolChain::addProfileRTLibs(Args, CmdArgs);
 }
 
 ToolChain::CXXStdlibType AIX::GetDefaultCXXStdlibType() const {
   return ToolChain::CST_Libcxx;
 }
 
 ToolChain::RuntimeLibType AIX::GetDefaultRuntimeLibType() const {
   return ToolChain::RLT_CompilerRT;
 }
 
 auto AIX::buildAssembler() const -> Tool * { return new aix::Assembler(*this); }
 
 auto AIX::buildLinker() const -> Tool * { return new aix::Linker(*this); }

clang/lib/Frontend/CompilerInstance.cpp

OS << "clang -cc1 version " CLANG_VERSION_STRING << " based upon LLVM "
        << llvm::sys::getDefaultTargetTriple() << "\n";
 
   if (getCodeGenOpts().TimePasses)
     createFrontendTimer();
 
   if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
     llvm::EnableStatistics(false);
 
+  // Sort vectors containing toc data and no toc data variables to facilitate
+  // binary search later.
+  llvm::sort(getCodeGenOpts().TocDataVarsUserSpecified);
+  llvm::sort(getCodeGenOpts().NoTocDataVars);
+
   for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
     // Reset the ID tables if we are reusing the SourceManager and parsing
     // regular files.
     if (hasSourceManager() && !Act.isModelParsingAction())
       getSourceManager().clearIDTables();
 
     if (Act.BeginSourceFile(*this, FIF)) {
       if (llvm::Error Err = Act.Execute()) {

clang/test/CodeGen/PowerPC/toc-data-attribute.c

+// RUN: %clang_cc1 %s -triple powerpc-ibm-aix-xcoff -S -mtocdata=f,g,h,i,j,k,l,m,n,o,p -emit-llvm -o - 2>&1 | FileCheck %s -check-prefixes=CHECK32 --match-full-lines
+// RUN: %clang_cc1 %s -triple powerpc-ibm-aix-xcoff -S -mtocdata -emit-llvm -o - 2>&1 | FileCheck %s -check-prefixes=CHECK32 --match-full-lines
+
+// RUN: %clang_cc1 %s -triple powerpc64-ibm-aix-xcoff -S -mtocdata=f,g,h,i,j,k,l,m,n,o,p -emit-llvm -o - 2>&1 | FileCheck %s -check-prefixes=CHECK64 --match-full-lines
+// RUN: %clang_cc1 %s -triple powerpc64-ibm-aix-xcoff -S -mtocdata -emit-llvm -o - 2>&1 | FileCheck %s -check-prefixes=CHECK64 --match-full-lines
+
+extern int f;
+long long g = 5;
+const char *h = "h";
+int *i;
+int __attribute__((aligned(128))) j = 0;
+float k = 100.00;
+double l = 2.5;
+int m __attribute__((section("foo"))) = 10;
+__thread int n;
+
+extern int p[];
+
+struct SomeStruct;
+extern struct SomeStruct o;
+
+static int func_a() {
+  return g+(int)h[0]+*i+j+k+l+m+n+p[0];
+}
+
+int func_b() {
+  f = 1;
+  return func_a();
+}
+
+struct SomeStruct* getAddress(void) {
+  return &o;
+}
+
+// CHECK32: @g = global i64 5, align 8
+// CHECK32: {{.*}}  = private unnamed_addr constant [2 x i8] c"h\00", align 1
+// CHECK32: @h = global {{...*}} #0
+// CHECK32: @j = global i32 0, align 128
+// CHECK32: @k = global float 1.000000e+02, align 4 #0
+// CHECK32: @l = global double 2.500000e+00, align 8
+// CHECK32: @m = global i32 10, section "foo", align 4
+// CHECK32: @f = external global i32, align 4 #0
+// CHECK32: @o = external global %struct.SomeStruct, align 1
+// CHECK32: @i = global ptr null, align 4 #0
+// CHECK32: @n = thread_local global i32 0, align 4
+// CHECK32: @p = external global [0 x i32], align 4
+// CHECK32: attributes #0 = { "toc-data" }
+
+// CHECK64: @g = global i64 5, align 8 #0
+// CHECK64: {{.*}}  = private unnamed_addr constant [2 x i8] c"h\00", align 1
+// CHECK64: @h = global {{...*}} #0
+// CHECK64: @j = global i32 0, align 128
+// CHECK64: @k = global float 1.000000e+02, align 4 #0
+// CHECK64: @l = global double 2.500000e+00, align 8 #0
+// CHECK64: @m = global i32 10, section "foo", align 4
+// CHECK64: @f = external global i32, align 4 #0
+// CHECK64: @o = external global %struct.SomeStruct, align 1
+// CHECK64: @i = global ptr null, align 8 #0
+// CHECK64: @n = thread_local global i32 0, align 4
+// CHECK64: @p = external global [0 x i32], align 4
+// CHECK64: attributes #0 = { "toc-data" }

clang/test/CodeGen/PowerPC/toc-data-attribute.cpp

+// RUN: %clang_cc1 %s -triple powerpc-ibm-aix-xcoff -S -mtocdata -emit-llvm -o - 2>&1 | FileCheck %s -check-prefixes=CHECK32
+// RUN: %clang_cc1 %s -triple powerpc-ibm-aix-xcoff -S -mtocdata=_ZL1s,_ZZ4testvE7counter,_ZN11MyNamespace10myVariableE -emit-llvm -o - 2>&1 | FileCheck %s -check-prefixes=CHECK32WARN 
+// RUN: %clang_cc1 %s -triple powerpc-ibm-aix-xcoff -S -mtocdata -mno-tocdata=_ZL1s,_ZZ4testvE7counter,_ZN11MyNamespace10myVariableE -emit-llvm -o - 2>&1 | FileCheck %s -check-prefixes=CHECK32WARNNOTOC 
+// RUN: %clang_cc1 %s -triple powerpc64-ibm-aix-xcoff -S -mtocdata -emit-llvm -o - 2>&1 | FileCheck %s -check-prefixes=CHECK64 
+// RUN: %clang_cc1 %s -triple powerpc64-ibm-aix-xcoff -S -mtocdata=_ZL1s,_ZZ4testvE7counter,_ZN11MyNamespace10myVariableE -emit-llvm -o - 2>&1 | FileCheck %s -check-prefixes=CHECK64WARN 
+// RUN: %clang_cc1 %s -triple powerpc64-ibm-aix-xcoff -S -mtocdata -mno-tocdata=_ZL1s,_ZZ4testvE7counter,_ZN11MyNamespace10myVariableE -emit-llvm -o - 2>&1 | FileCheck %s -check-prefixes=CHECK64WARNNOTOC 
+
+extern int n;
+static int s = 100;
+
+inline int test() {
+    static int counter = 0;
+    counter++;
+    return counter;
+}
+
+int a () {
+    n = test();
+    return 0;
+}
+
+namespace MyNamespace {
+    int myVariable = 10;
+}
+
+int b(int x) {
+    using namespace MyNamespace;
+    return x + myVariable;
+}
+
+int c(int x) {
+  s += x;
+  return s;
+}
+
+// CHECK32: @_ZN11MyNamespace10myVariableE = global i32 10, align 4 #0
+// CHECK32: @_ZL1s = internal global i32 100, align 4 #0
+// CHECK32: @_ZZ4testvE7counter = linkonce_odr global i32 0, align 4 #0
+// CHECK32: attributes #0 = { "toc-data" }
+
+// CHECK32WARN: The -m[no-]tocdata option is ignored for _ZZ4testvE7counter because variable does not have external linkage
+// CHECK32WARN: The -m[no-]tocdata option is ignored for _ZL1s because variable does not have external linkage
+// CHECK32WARN: @_ZN11MyNamespace10myVariableE = global i32 10, align 4 #0
+// CHECK32WARN-NOT: @_ZL1s = internal global i32 100, align 4 #0
+// CHECK32WARN-NOT: @_ZZ4testvE7counter = linkonce_odr global i32 0, align 4 #0
+// CHECK32WARN: attributes #0 = { "toc-data" }
+
+// CHECK32WARNNOTOC: The -m[no-]tocdata option is ignored for _ZZ4testvE7counter because variable does not have external linkage
+// CHECK32WARNNOTOC: The -m[no-]tocdata option is ignored for _ZL1s because variable does not have external linkage
+// CHECK32WARNNOTOC-NOT: @_ZN11MyNamespace10myVariableE = global i32 10, align 4 #0
+// CHECK32WARNNOTOC: @_ZL1s = internal global i32 100, align 4 #0
+// CHECK32WARNNOTOC: @_ZZ4testvE7counter = linkonce_odr global i32 0, align 4 #0
+// CHECK32WARNNOTOC: attributes #0 = { "toc-data" }
+
+
+// CHECK64: @_ZN11MyNamespace10myVariableE = global i32 10, align 4 #0
+// CHECK64: @_ZL1s = internal global i32 100, align 4 #0
+// CHECK64: @_ZZ4testvE7counter = linkonce_odr global i32 0, align 4 #0
+// CHECK64: attributes #0 = { "toc-data" }
+
+// CHECK64WARN: The -m[no-]tocdata option is ignored for _ZZ4testvE7counter because variable does not have external linkage
+// CHECK64WARN: The -m[no-]tocdata option is ignored for _ZL1s because variable does not have external linkage
+// CHECK64WARN: @_ZN11MyNamespace10myVariableE = global i32 10, align 4 #0
+// CHECK64WARN-NOT: @_ZL1s = internal global i32 100, align 4 #0
+// CHECK64WARN-NOT: @_ZZ4testvE7counter = linkonce_odr global i32 0, align 4 #0
+// CHECK64WARN: attributes #0 = { "toc-data" }
+
+// CHECK64WARNNOTOC: The -m[no-]tocdata option is ignored for _ZZ4testvE7counter because variable does not have external linkage
+// CHECK64WARNNOTOC: The -m[no-]tocdata option is ignored for _ZL1s because variable does not have external linkage
+// CHECK64WARNNOTOC-NOT: @_ZN11MyNamespace10myVariableE = global i32 10, align 4 #0
+// CHECK64WARNNOTOC: @_ZL1s = internal global i32 100, align 4 #0
+// CHECK64WARNNOTOC: @_ZZ4testvE7counter = linkonce_odr global i32 0, align 4 #0
+// CHECK64WARNNOTOC: attributes #0 = { "toc-data" }

clang/test/CodeGen/PowerPC/toc-data-diagnostics.c

+// RUN: %clang_cc1 %s -triple=powerpc-ibm-aix-xcoff -S -mtocdata=h,g,f,e,d,c,b,a -verify -emit-llvm -o - | FileCheck %s -check-prefix=CHECK --match-full-lines
+// RUN: %clang_cc1 %s -triple=powerpc-ibm-aix-xcoff -S -mtocdata -verify=none -emit-llvm -o - | FileCheck %s -check-prefix=CHECK --match-full-lines
+
+// none-no-diagnostics
+
+struct large_struct {
+  int x;
+  short y;
+  short z;
+  char c;
+};
+
+struct large_struct a;                      // expected-warning {{The -m[no-]tocdata option is ignored for a because variable is larger than a pointer.}}
+long long b = 5;                            // expected-warning {{The -m[no-]tocdata option is ignored for b because variable is larger than a pointer.}}
+int __attribute__((aligned(128))) c = 0;    // expected-warning {{The -m[no-]tocdata option is ignored for c because variable is aligned wider than a pointer.}}
+double d = 2.5;                             // expected-warning {{The -m[no-]tocdata option is ignored for d because variable is larger than a pointer.}}
+int e __attribute__((section("foo"))) = 10; // expected-warning {{The -m[no-]tocdata option is ignored for e because of a section attribute.}}
+__thread int f;                             // expected-warning {{The -m[no-]tocdata option is ignored for f because of thread local storage model.}}
+
+struct SomeStruct;
+extern struct SomeStruct g;                 // expected-warning {{The -m[no-]tocdata option is ignored for g because of incomplete type.}}
+
+extern int h[];                             // expected-warning {{The -m[no-]tocdata option is ignored for h because of incomplete type.}}
+
+int func() {
+  return a.x+b+c+d+e+f+h[0];
+}
+
+struct SomeStruct* getAddress(void) {
+  return &g;
+}
+
+// CHECK: @b = global i64 5, align 8
+// CHECK: @c = global i32 0, align 128
+// CHECK: @d = global double 2.500000e+00, align 8
+// CHECK: @e = global i32 10, section "foo", align 4
+// CHECK: @a = global %struct.large_struct zeroinitializer, align 4
+// CHECK: @f = thread_local global i32 0, align 4
+// CHECK: @h = external global [0 x i32], align 4
+// CHECK: @g = external global %struct.SomeStruct, align 1
+// CHECK-NOT: attributes {{.*}} = { "toc-data" }

clang/test/CodeGen/PowerPC/toc-data-structs-arrays.cpp

+// RUN: %clang_cc1 %s -triple powerpc-ibm-aix-xcoff -S -mtocdata=a4,a5,a8,a9,b,c,d,e,v -emit-llvm -o - 2>&1 \
+// RUN:          | FileCheck %s -check-prefixes=CHECK32 --match-full-lines
+// RUN: %clang_cc1  %s -triple powerpc-ibm-aix-xcoff -S -mtocdata -emit-llvm -o - 2>&1 \
+// RUN:          | FileCheck %s -check-prefixes=CHECK32 --match-full-lines
+
+// RUN: %clang_cc1  %s -triple powerpc64-ibm-aix-xcoff -S -mtocdata=a4,a5,a8,a9,b,c,d,e,v -emit-llvm -o - 2>&1 \
+// RUN:          | FileCheck %s -check-prefixes=CHECK64 --match-full-lines
+// RUN: %clang_cc1  %s -triple powerpc64-ibm-aix-xcoff -S -mtocdata -emit-llvm -o - 2>&1 \
+// RUN:          | FileCheck %s -check-prefixes=CHECK64 --match-full-lines
+
+struct size4_struct {
+  int x;
+};
+
+struct size5_struct {
+  int x;
+  char c;
+};
+
+struct size8_struct {
+  int x;
+  short y;
+  short z;
+};
+
+struct size9_struct {
+  int x;
+  short y;
+  short z;
+  char c;
+};
+
+struct size4_struct a4;
+struct size5_struct a5;
+struct size8_struct a8;
+struct size9_struct a9;
+
+short b[2];
+short c[3];
+short d[4];
+short e[5];
+
+int func_a() {
+  return a4.x+a5.x+a8.x+a9.x+b[0]+c[0]+d[0]+e[0];
+}
+
+// CHECK32: @a4 = global %struct.size4_struct zeroinitializer, align 4 #0
+// CHECK32: @a5 = global %struct.size5_struct zeroinitializer, align 4
+// CHECK32: @a8 = global %struct.size8_struct zeroinitializer, align 4
+// CHECK32: @a9 = global %struct.size9_struct zeroinitializer, align 4
+// CHECK32: @b = global [2 x i16] zeroinitializer, align 2 #0
+// CHECK32: @c = global [3 x i16] zeroinitializer, align 2
+// CHECK32: @d = global [4 x i16] zeroinitializer, align 2
+// CHECK32: @e = global [5 x i16] zeroinitializer, align 2
+// CHECK32: attributes #0 = { "toc-data" }
+
+// CHECK64: @a4 = global %struct.size4_struct zeroinitializer, align 4 #0
+// CHECK64: @a5 = global %struct.size5_struct zeroinitializer, align 4 #0
+// CHECK64: @a8 = global %struct.size8_struct zeroinitializer, align 4 #0
+// CHECK64: @a9 = global %struct.size9_struct zeroinitializer, align 4
+// CHECK64: @b = global [2 x i16] zeroinitializer, align 2 #0
+// CHECK64: @c = global [3 x i16] zeroinitializer, align 2 #0
+// CHECK64: @d = global [4 x i16] zeroinitializer, align 2 #0
+// CHECK64: attributes #0 = { "toc-data" }

clang/test/CodeGen/toc-data.c

+// RUN: %clang_cc1 %s -triple powerpc-unknown-aix -S -mtocdata=g1,g2,g3 -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-MIX --match-full-lines
+// RUN: %clang_cc1 %s -triple powerpc64-unkown-aix -S -mtocdata -mno-tocdata=g4,g5 -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-MIX --match-full-lines
+
+// RUN: %clang_cc1 %s -triple powerpc-unknown-aix -S -mno-tocdata -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-NOTOCDATA
+// RUN: %clang_cc1 %s -triple powerpc64-unknown-aix -S -mno-tocdata -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-NOTOCDATA
+
+// RUN: %clang_cc1 %s -triple powerpc-unknown-aix -S -mtocdata -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-TOCDATA --match-full-lines
+// RUN: %clang_cc1 %s -triple powerpc64-unknown-aix -S -mtocdata -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-TOCDATA --match-full-lines
+
+int g1, g4;
+extern int g2;
+int g3 = 0, g5 = 123;
+void func() {
+  g2 = 0;
+}
+
+// CHECK-MIX-DAG: @g3 = global i32 0, align 4 #0
+// CHECK-MIX-DAG: @g2 = external global i32, align 4 #0
+// CHECK-MIX-DAG: @g1 = global i32 0, align 4 #0
+// CHECK-MIX-DAG: @g4 = global i32 0, align 4
+// CHECK-MIX-DAG: @g5 = global i32 123, align 4
+// CHECK-MIX: attributes #0 = { "toc-data" }
+
+// CHECK-NOTOCDATA-NOT: "toc-data"
+
+// CHECK-TOCDATA-DAG: @g3 = global i32 0, align 4 #0
+// CHECK-TOCDATA-DAG: @g2 = external global i32, align 4 #0
+// CHECK-TOCDATA-DAG: @g1 = global i32 0, align 4 #0
+// CHECK-TOCDATA-DAG: @g4 = global i32 0, align 4 #0
+// CHECK-TOCDATA-DAG: @g5 = global i32 123, align 4 #0
+// CHECK-TOCDATA: attributes #0 = { "toc-data" }

clang/test/Driver/toc-conf.c

+// RUN: %clang %s --target=powerpc-unknown-aix -mno-tocdata -mtocdata -mno-tocdata -### 2>&1 | FileCheck %s -check-prefix=CHECK-FLAG1
+// RUN: %clang %s --target=powerpc-unknown-aix -mno-tocdata -mtocdata -mno-tocdata -mtocdata -### 2>&1 | FileCheck %s -check-prefix=CHECK-FLAG2
+// RUN: %clang %s --target=powerpc-unknown-aix -mtocdata=g1,g2 -mno-tocdata=g2 -mtocdata=g3,g4 -mno-tocdata=g5,g1 -### 2>&1 | FileCheck %s -check-prefix=CHECK-EQCONF
+// RUN: %clang %s --target=powerpc-unknown-aix -mtocdata=g1 -mtocdata -mno-tocdata -mtocdata=g2,g3 -mno-tocdata=g4,g5,g3 -### 2>&1 | FileCheck %s -check-prefix=CHECK-CONF1
+// RUN: %clang %s --target=powerpc-unknown-aix -mno-tocdata=g1 -mno-tocdata -mtocdata -### 2>&1 | FileCheck %s -check-prefix=CHECK-CONF2
+
+int g1, g4, g5;
+extern int g2;
+int g3 = 0;
+void func() {
+  g2 = 0;
+}
+
+// CHECK-FLAG1-NOT: warning:
+// CHECK-FLAG1: "-cc1"{{.*}}" "-mno-tocdata"
+
+// CHECK-FLAG2-NOT: warning:
+// CHECK-FLAG2: "-cc1"{{.*}}" "-mtocdata"
+
+// CHECK-EQCONF-NOT: warning:
+// CHECK-EQCONF: "-cc1"{{.*}}" "-mno-tocdata"
+// CHECK-EQCONF: "-mtocdata=g3,g4"
+
+// CHECK-CONF1-NOT: warning:
+// CHECK-CONF1: "-cc1"{{.*}}" "-mno-tocdata"
+// CHECK-CONF1: "-mtocdata=g2,g1"
+
+// CHECK-CONF2-NOT: warning:
+// CHECK-CONF2: "-cc1"{{.*}}" "-mtocdata"
+// CHECK-CONF2: "-mno-tocdata=g1"

clang/test/Driver/tocdata-cc1.c

+// RUN: %clang -### --target=powerpc-ibm-aix-xcoff -mcmodel=medium -mtocdata %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-NOTOC %s
+// RUN: %clang -### --target=powerpc-ibm-aix-xcoff -mcmodel=large -mtocdata %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-NOTOC %s
+// RUN: %clang -### --target=powerpc-ibm-aix-xcoff -mtocdata %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-TOC %s
+// RUN: %clang -### --target=powerpc64-ibm-aix-xcoff -mcmodel=medium -mtocdata %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-NOTOC %s
+// RUN: %clang -### --target=powerpc64-ibm-aix-xcoff -mcmodel=large -mtocdata %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-NOTOC %s
+// RUN: %clang -### --target=powerpc64-ibm-aix-xcoff -mtocdata %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-TOC %s
+// CHECK-NOTOC: warning: ignoring '-mtocdata' as it is only supported for -mcmodel=small
+// CHECK-NOTOC-NOT: "-cc1"{{.*}}" "-mtocdata"
+// CHECK-TOC: "-cc1"{{.*}}" "-mtocdata"
+// CHECK-TOC-NOT: warning: ignoring '-mtocdata' as it is only supported for -mcmodel=small

llvm/include/llvm/ADT/STLExtras.h

 
 /// Provide wrappers to std::partition which take ranges instead of having to
 /// pass begin/end explicitly.
 template <typename R, typename UnaryPredicate>
 auto partition(R &&Range, UnaryPredicate P) {
   return std::partition(adl_begin(Range), adl_end(Range), P);
 }
 
+/// Provide wrappers to std::binary_search which take ranges instead of having
+/// to pass begin/end explicitly.
+template <typename R, typename T> auto binary_search(R &&Range, T &&Value) {
+  return std::binary_search(adl_begin(Range), adl_end(Range),
+                            std::forward<T>(Value));
+}
+
+template <typename R, typename T, typename Compare>
+auto binary_search(R &&Range, T &&Value, Compare C) {
+  return std::binary_search(adl_begin(Range), adl_end(Range),
+                            std::forward<T>(Value), C);
+}
+
 /// Provide wrappers to std::lower_bound which take ranges instead of having to
 /// pass begin/end explicitly.
 template <typename R, typename T> auto lower_bound(R &&Range, T &&Value) {
   return std::lower_bound(adl_begin(Range), adl_end(Range),
                           std::forward<T>(Value));
 }
 
 template <typename R, typename T, typename Compare>

llvm/lib/MC/MCSectionXCOFF.cpp

if (getKind().isData()) {
     default:
       report_fatal_error(
           "Unhandled storage-mapping class for .data csect.");
     }
     return;
   }
 
   if (isCsect() && getMappingClass() == XCOFF::XMC_TD) {
-    assert((getKind().isBSSExtern() || getKind().isBSSLocal()) &&
-           "Unexepected section kind for toc-data");
+    assert(getKind().isBSS() && "Unexepected section kind for toc-data");
     printCsectDirective(OS);
     return;
   }
   // Common csect type (uninitialized storage) does not have to print csect
   // directive for section switching.
   if (isCsect() && getCSectType() == XCOFF::XTY_CM) {
     assert((getMappingClass() == XCOFF::XMC_RW ||
             getMappingClass() == XCOFF::XMC_BS ||

llvm/lib/Target/PowerPC/PPCISelDAGToDAG.cpp

assert(
       "GlobalVariables with an alignment requirement stricter than TOC entry "
       "size not supported by the toc data transformation.");
 
   Type *GVType = GV->getValueType();
 
   assert(GVType->isSized() && "A GlobalVariable's size must be known to be "
                               "supported by the toc data transformation.");
 
-  if (GVType->isVectorTy())
-    report_fatal_error("A GlobalVariable of Vector type is not currently "
-                       "supported by the toc data transformation.");
-
-  if (GVType->isArrayTy())
-    report_fatal_error("A GlobalVariable of Array type is not currently "
-                       "supported by the toc data transformation.");
-
-  if (GVType->isStructTy())
-    report_fatal_error("A GlobalVariable of Struct type is not currently "
-                       "supported by the toc data transformation.");
-
-  assert(GVType->getPrimitiveSizeInBits() <= PointerSize * 8 &&
-         "A GlobalVariable with size larger than a TOC entry is not currently "
-         "supported by the toc data transformation.");
+  if (GV->getParent()->getDataLayout().getTypeSizeInBits(GVType) >
+      PointerSize * 8)
+    report_fatal_error(
 
   if (GV->hasLocalLinkage() || GV->hasPrivateLinkage())
     report_fatal_error("A GlobalVariable with private or local linkage is not "
                        "currently supported by the toc data transformation.");
 
   assert(!GV->hasCommonLinkage() &&
          "Tentative definitions cannot have the mapping class XMC_TD.");
 

llvm/test/CodeGen/PowerPC/toc-data-large-array.ll

+; RUN: not --crash llc -mtriple powerpc-ibm-aix-xcoff < %s 2>&1 | FileCheck %s --check-prefix CHECK-ERROR
+; RUN: not --crash llc -mtriple powerpc64-ibm-aix-xcoff < %s 2>&1 | FileCheck %s --check-prefix CHECK-ERROR
+
+@a = global [5 x i16] zeroinitializer, align 2 #0
+
+; Function Attrs: noinline
+define i16 @foo() #1 {
+entry:
+  %0 = load i16, ptr @a, align 2
+  ret i16 %0
+}
+
+attributes #0 = { "toc-data" }
+attributes #1 = { noinline }
+
+; CHECK-ERROR: LLVM ERROR: A GlobalVariable with size larger than a TOC entry is not currently supported by the toc data transformation.

llvm/test/CodeGen/PowerPC/toc-data-struct-array.ll

+; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s --check-prefix CHECK
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s | FileCheck %s --check-prefix CHECK
+
+%struct.small_struct = type { i16 }
+
+@a = global %struct.small_struct zeroinitializer, align 2 #0
+@b = global [2 x i16] zeroinitializer, align 2 #0
+
+; Function Attrs: noinline
+define i16 @foo() #1 {
+entry:
+  %0 = load i16, ptr @a, align 2
+  %1 = load i16, ptr @b, align 2
+  %add = add nsw i16 %0, %1
+  ret i16 %add
+}
+
+attributes #0 = { "toc-data" }
+attributes #1 = { noinline }
+
+; CHECK:      .toc
+; CHECK-NEXT: .csect a[TD],2
+; CHECK-NEXT: .globl    a[TD]                           # @a
+; CHECK-NEXT: .align    1
+; CHECK-NEXT: .space    2
+; CHECK-NEXT: .csect b[TD],2
+; CHECK-NEXT: .globl    b[TD]                           # @b
+; CHECK-NEXT: .align    1
+; CHECK-NEXT: .space    4