[llvm-ar] Add object mode option -X for AIX

[DiggerLin]

Summary

1. Added a new option object mode -X for llvm-ar. In AIX OS , there is a object mode option -X for ar command.

please see the "-X mode" part of https://www.ibm.com/docs/ko/aix/7.1?topic=ar-command

Specifies the type of object file ar should examine. The mode must be one of the following:
32
Processes only 32-bit object files
64
Processes only 64-bit object files
32_64
Processes both 32-bit and 64-bit object files
any
Processes all of the supported object files.

The default is to process 32-bit object files (ignore 64-bit objects). The mode can also be set with the OBJECT_MODE environment variable. For example, OBJECT_MODE=64 causes ar to process any 64-bit objects and ignore 32-bit objects. The -X flag overrides the OBJECT_MODE variable.

2. Before adding the new option -X, the default behaviors of llvm-ar like -Xany, but after the adding the new option -X, the default behaviors of llvm-ar change to -X32 ,in order to let some test cases which has 32bit and 64bit object file in the same llvm-ar command, we need to add the "export OBJECT_MODE=any" into test case to change the default behaviors of llvm-ar's object mode.

[shchenz]

Out of curious, why do we need to add -X option to llvm-ar like AIX system ar? If llvm-ar can automaticly detect the object file format on any OBJECT_MODE and generate related archive file, seems it is better than system ar?

[DiggerLin]

reformat llvm-ar.rst with Sphinx

[MaskRay]

[AIX] add object mode -X option for llvm-ar on AIX OS.

Maybe [llvm-ar] Add object mode option -X for AIX?

The convention does not add a period on the subject line.

[daltenty]

In D127864#3585586, @shchenz wrote:

Out of curious, why do we need to add -X option to llvm-ar like AIX system ar? If llvm-ar can automaticly detect the object file format on any OBJECT_MODE and generate related archive file, seems it is better than system ar?

There is still an interface compatibility problem without the option, many build system tools (e.g. CMake) will automatically generate the flag on AIX, so it's needed to be able to use llvm-ar as a drop in replacement for the system ar.

[jhenderson]

The pre-merge checks are showing up failures caused by this patch. Please fix them.

I've not looked at the tests yet.

llvm/docs/CommandGuide/llvm-ar.rst

299

I don't like the word "examine" here. llvm-ar is usually about manipulating archives, as much as (if not more than) inspecting them. How about "will recognise" instead of "should examine"?

308

I don't think "supported" is really necessary, so let's keep the message simple.

llvm/tools/llvm-ar/llvm-ar.cpp

649

I don't know what you mean by "SymbolList" here and why that has anything to do with bitness.

665

Please fix this function name to conform to LLVM coding standards.

670

This would be a more normal way of calling it.

675–676

680

Please fix this function name to conform to LLVM coding standards.

681

Delete the extra blank line.

686–687

Same comment change request as above.

702

Please fix this function name to conform to LLVM coding standards.

This function looks pretty much identical to the one above. Please refactor the code to avoid duplication.

739–740

Does this check need to be inside if (Filter)? It seems like it's unnecessary and you can avoid duplicating the check in the else if by moving it out.

807–808

I don't like this AT ALL. It would seem FAR better if you check the type of the object BEFORE actually doing any work with it. That way, you don't have to undo any modifications that you might have made.

1270

Please make this function name conform to LLVM style.

1328

1330

Is "OBJECT_MODE" an environment variable from AIX ar or is it specific to llvm-ar? If the latter, why do you need it?

1332

Is this the same default value as on AIX? I'd expect "any" to make much more sense as a default (but we should do what AIX ar does).

1391–1392

What's the motivation for making this AIX OS only?

1396

This message does not conform to the LLVM coding standard for error messages. Please fix it.

1399

This message does not conform to the LLVM coding standard for error messages. Please fix it.

Additionally "in no AIX OS" -> "on non-AIX OS"

[DiggerLin]

llvm/tools/llvm-ar/llvm-ar.cpp

649

thanks, change to is64BitSymbolicFile

665

thanks

670

thanks

680

thanks

739–740

good catch, thanks

807–808

if we check the object BEFORE, the file will be opened checking for object mode, and we need to open the file somewhere as NewArchiveMember . otherwise we have to open the "FileName" again.

if we open the "FileName" and keep as NewArchiveMember somewhere, the problem is that if the FileName is archive , it can not be kept in the NewArchiveMember.

1270

thanks

1332

if there is no OBJECT_MODE environment variable set and no -X option in AIX "ar" , The default is to process 32-bit object files (ignore 64-bit objects).
https://www.ibm.com/docs/ko/aix/7.1?topic=ar-command

1391–1392

I think to make -X for all the non AIX OS before, but in the AIX, The default is to process 32-bit object files (ignore 64-bit objects). but for other non AIX OS, the default is to process both 32 and 64 bits object file. it maybe caused problem for the script which llvm-ar.

if you think it is better to let -X work for non AIX OS, I can make
default for AIX is 32bit, for non AIX OS, the default is any.

[DiggerLin]

address comment

[jhenderson]

I'm going to leave my review there, but haven't finished the test. Please address my comments and then I'll finish reviewing the test case.

llvm/test/Object/X86/archive-symbol-table.s

1 ↗

(On Diff #438015)

I don't like the need for this in every single llvm-ar test. I would prefer it if this variable is set by default in the lit harness, and then just explicitly unset in the test(s) where we want to test the AIX behaviour.

llvm/test/tools/llvm-ar/invalid-option-X.test

3

"Test that the -X option is not supported on non-AIX OS."

6

No need for a check prefix other than the default CHECK when you only have one test case in the file.

7

Nit: there's a trailing space at the end of this line. Please delete it.

llvm/test/tools/llvm-ar/option-X.test

4

6–8

15

That being said, this first test case doesn't test the new option at all. It just uses the default behaviour.

16

No need for this: you haven't created the file yet, and you deleted the directory you are working in.

17

No need for %t when you cd'ed into a directory - just use a name specific to the test case, in this case something like default-create.a (i.e. it's the default behaviour for creating a new archive). Same sort of thing goes for the other test cases too.

Your new code checks for 32 versus 64 for each of a number of different formats, not just XCOFF and ELF. You should test each of them in at least one test case.

18–20

I'd also recommend using INFO-64 i.e. a hyphen instead of an underscore.

Same comments and edits apply throughout.

22–23

Should the second of these use the -NEXT suffix?

31

Add comments explaining what each test case is doing. E.g. here it is saying that the -X option overrides the environment variable.

Additionally, the norm for setting environment variables is to use the env command at the start of the RUN line you want to modify, e.g.

# RUN: env OBJECT_MODE=64 llvm-ar ...

33

This line isn't a RUN line so won't do anything, but regardless, see above.

llvm/tools/llvm-ar/llvm-ar.cpp

662

There's a real risk that if a new object file format is added that this will result in an assertion/crash. It's probably better to do a dyn_cast for ELFObjectFileBase, like the other formats and then report an error (e.g. "unsupported file format" if it is none of the known formats.

695–696

I think this phrasing is a little cleaner.

728

738

Delete this unrelated change.

840

This should probably be printed as a warning (and follow the coding standards for warnings and errors).

Same goes with the other areas reporting this kind of message.

968

@gbreynoo, can you take a look at this area of the change in particular, please, and see if it is the best we can do given how llvm-ar is structured? I'm very rusty on the code logic, so don't feel comfortable saying whether this is the best approach or coming up with a better one.

972

1391–1392

Having thought about it, I think -X should be AIX only, as it's less likely to cause a problem with another short option appearing in GNU ar and causing a name clash.

1396

Use Twine rather than std::string here to perform the concatenation. Convert to std::string only once the whole thing is concatenated (if needed).

[DiggerLin]

llvm/test/tools/llvm-ar/option-X.test

15

it test the default option is as -X32 without -X option in command and no "OBJECT_MODE" set in environment.

31

thanks

[jhenderson]

llvm/test/Object/lit.local.cfg

1–2 ↗

(On Diff #439797)

I'd add a comment explaining this variable briefly.

I also think it would make sense to move this into the top-level lit config, rather than a subdirectory, because it impacts all uses of llvm-ar. llvm-ar is commonly used to create inputs for tests at runtime, and these could appear in virtually any directory within llvm/test (not to mention possibly even other subprojects, such as lld, but I'm less concerned there).

llvm/test/tools/llvm-ar/option-X.test

22–23

Ping this comment? It seems to have been ignored.

24

I said this once already - don't delete archives that don't exist! The directory was deleted and recreated at the start of the test. Use a unique name for each test case too, e.g. don't reuse archive.a in multiple test cases, instead use create-default.a, create-32.a, create-64.a etc (with names that describe the test case). This way you a) don't have to rename the test, and b) can inspect the archive for each test case after running it without having to do strange things like delete parts of the test.

This applies throughout the test.

25

Did you mean to run FileCheck on this line? The 2>&1 implies you either a copy-paste error or that you meant to check for a warning.

29

38

You've still got a double space between %s and the --check-prefixes option here. Please remove it from here and all other cases.

In general, when I make a comment, please make sure you've addressed all occurrences of the issue I raised, rather than just the one, as it will speed up the review and save us both time.

180

Please remember to include a space between your # and the check directive.

201

I think you're trying to say "Test -X option with other output formats." right? You don't need to list them out specifically (the test case is clear enough).

Is there a reason you've got ELF in the earlier test cases, rather than down here? I think it would make the earlier tests simpler to use just one file format in the earlier test cases (probably XCOFF) and then just this simple test for the other ones (including ELF).

If you go down this route, make sure you don't lose test coverage that shows that llvm-ar warns for every object it doesn't process, not just the first one. This could be achieved by checking the warnings in this test case, I believe.

llvm/tools/llvm-ar/llvm-ar.cpp

699–700

I'm not sure I follow the need for this bit of code? Has something else been rebased that requires it, and if so, could you explain why it's correct to use it the way you've done (i.e. with the setOpaquePointers(true), please.

840

llvm-ar.cpp already prints one other warning in this file (see https://github.com/llvm/llvm-project/blob/ca2933f3f88a09eb485146eef776b7345e3d87d3/llvm/tools/llvm-ar/llvm-ar.cpp#L1021). To ensure consistency, we should factor all the call sites into a function that prints the warning. Note that the other case includes the toolname, for example, which this doesn't.

972–976

We should probably move this code into a separate function, so that the message is not repeated in three different cases. That function would then call the proposed generic print warning function suggested above.

[DiggerLin]

llvm/test/tools/llvm-ar/option-X.test

38

thanks , I will do it.

180

thanks

201

Is there a reason you've got ELF in the earlier test cases, rather than down here? I think it would make the earlier tests simpler to use just one file format in the earlier test cases (probably XCOFF) and then just this simple test for the other ones (including ELF).

there is no special reason to got the ELF in the earlier test cases, but it is no harm to ELF in the earlier test case. And if only letting the earlier test cases only test xcoff32.o and xcoff64.o, I think it is too simple, so I put the earlier test cases test on the xcoff32.o elf32.o xcoff64.o elf64.o

If you go down this route, make sure you don't lose test coverage that shows that llvm-ar warns for every object it doesn't process, not just the first one. This could be achieved by checking the warnings in this test case, I believe

when we checking the warning functionality of "is not valid with the current object file mode" , I think we only need to check once, we do not need to check everywhere ? is it correct?

llvm/tools/llvm-ar/llvm-ar.cpp

699–700

we add bitcode object file test in test case ,it need a LLVMContext to createBinary for bit code.
https://github.com/llvm/llvm-project/blob/ca2933f3f88a09eb485146eef776b7345e3d87d3/llvm/lib/Object/SymbolicFile.cpp#L48

[DiggerLin]

address James' comment.

[DiggerLin]

llvm/test/tools/llvm-ar/option-X.test

201

And if only letting the earlier test cases only test xcoff32.o and xcoff64.o, I think it is too simple to test especially when testing move operation.

[jhenderson]

llvm/test/Object/lit.local.cfg

1–7 ↗

(On Diff #440614)

Delete the blank line between the comment and block of code it refers to.

I've also fixed a number of grammar errors, typos, etc, and removed all references to the command-line option from the comment, in the suggested edit: the code this comment is supposed to explain is about the environment variable only, and the command-line option is irrelevant to it (users reading this comment, don't need to know about a command-line option to understand why this code exists).

1–2 ↗

(On Diff #439797)

I also think it would make sense to move this into the top-level lit config, rather than a subdirectory, because it impacts all uses of llvm-ar. llvm-ar is commonly used to create inputs for tests at runtime, and these could appear in virtually any directory within llvm/test (not to mention possibly even other subprojects, such as lld, but I'm less concerned there).

You've ignored this. Please stop ignoring parts of my comments without explaining why at least.

llvm/test/tools/llvm-ar/option-X.test

14

You only test the default behaviour for archive creation, but you should also do it for the operations you test, I think.

15

Why have you dropped the warning checks from these cases?

57–58

Nit: In the -X cases, the "any" case comes before the 32_64 case. I don't mind the order, but it should be the same in all cases, for ease of review and maintenance.

72

Rather than repeatedly delete the objects, I think you should run each of these cases in a different directory (use mkdir and cd as needed), or use the new --output option added very recently (see rGbf223e43fe68) to specify a different directory each time.

74

The more common way to test for existence of a file is ls xcoff32.o. That being said, if you keep the original objects as described above, you could use cmp xcoff32.o ../xcoff32.o (or equivalent) instead for the cases where the file exists (you'd still want not ls for the missing cases).

100

You should also test the 32-bit object using -X64 case.

110

126

127

Why are you deleting objects here?

129–133

I think you should avoid this confusing situation by using a completely fresh set of objects and an archive created specifically for this test case. You could call the objects 1.o, 2.o etc, to help show the expected order. You should be able to reuse your earlier objects by simply copying them.

134

I'm not sure I understand the need for the u option in these test cases?

140–142

149

151

153

Prefer - to _ in check prefixes.

155

This should use the %errc_ENOENT lit substitution.

160

You need 32-bit equivalents of these test cases, and also to show the behaviour with the other -X options.

192–193

Why not just 32.bc and 64.bc?

201

Okay.

llvm/tools/llvm-ar/llvm-ar.cpp

840

You should quote FileName, so that it is clear if there's a space in the name.

972–976

This bit hasn't been addressed. I'm suggesting a new function like this:

static void warnInvalidObjectForFileMode(Twine Name) {
  warn(Name + " is not valid with the current object file mode");
}

To avoid repeating that string in multiple places.

[DiggerLin]

address comment

llvm/test/Object/lit.local.cfg

1–7 ↗

(On Diff #440614)

thanks

llvm/test/tools/llvm-ar/option-X.test

14

the code

if (object::Archive::getDefaultKindForHost() == object::Archive::K_AIXBIG) {
   BitMode = getBitMode(getenv("OBJECT_MODE"));
   if (BitMode == BitModeTy::Unknown)
     BitMode = BitModeTy::Bit32;
 }

is dependent of operations , so I think we only need to test default behavior to -X32 once at here is OK.

and I also using default behavior for the

1. Extract a 64-bit object file with option -X32(or default object mode).

15

I do not think we need to check the warning for each test. I tested the warning in the line 243~246 (etc), I do not think we need to test warning in each case.

22–23

I am sorry that I do not get the comment.

127

we need to delete all *.o before we test extract operation. I can delete the " rm -rf *.o" since I use --output for the extract operation.

129–133

here we need a same file xcoff32.o which is a 32 bit member is archive, when we want to replace with a 64 bit xcoff32.o and without option -X32, not change anything

134

yes , we do not need u here.

160

I added a -X32 of the test case , but I do not think I need to add additional -X32_64 -Xany for the "-ma" ,since we use the same
function

static bool isValidInBitMode(Binary &Bin)

for operation,
I have test -X32-64 and -Xany in other operation case.

[jhenderson]

llvm/test/lit.local.cfg

1 ↗

(On Diff #442939)

I guess I should have been more specific - top-level lit configuration goes in llvm/test/lit.cfg.py, not in a lit.local.cfg in the top level.

2–5 ↗

(On Diff #442939)

7 ↗

(On Diff #442939)

Delete this blank line (as requested before - the logic is still the same).

llvm/test/tools/llvm-ar/option-X.test

78

Nit: there's a double space here.

95–96

I'm not sure why you've added the -s option to the cmp commands. We want the output, so that if the test fails, we'll get told where the problem is in the test log.

118

127

154

158

I already suggested this fix once...

160

If the code changed to use a different function for the move case, then there would not be test coverage for it, hence why you should test all four cases, I think.

163

This is the canonical option for dumping the archive symbol table. If that's not what you meant to do, could you explain what you are trying to check with this line, please?

Same below.

179

Comments end with a ".".

Previously you had a test case that showed the if you tried to perform an operation on an object which didn't match the -X option, you'd get a "file not found" error. Whilst I accept that it probably follows the same code paths as other cases already tested, I think it's an important enough behaviour that you should have a specific test case for it somewhere (you don't need to test both 32 and 64 bit variations for that case though, I think).

181

Not sure why you ignored parts of my original edit...

182

Ditto below.

188

llvm/tools/llvm-ar/llvm-ar.cpp

711

Name still isn't quoted in the output. Please fix (and don't mark comments as "Done" if you haven't done them).

[DiggerLin]

llvm/test/tools/llvm-ar/option-X.test

163

there are two version of xcoff.o , one is 32-bit, other one is 64-bit,

the 32-bit xcoff.o has symbol var_0x1DF
the 64-bit xcoff.o has symbol var+0x1F7.

I want to check whether the only a 32-bit xcoff.o in the archive or both 32-bit and 64-bit xcoff.o in the archive, I need to check the symbol.

179

in original, the test scenario look like

1. RUN: llvm-ar -ma elf64.o archive.a xcoff64.o 2>&1 | \
2. RUN: FileCheck %s --check-prefix=MOVE_ERR
3. MOVE_ERR: llvm-ar: error: xcoff64.o: No such file or directory

it because we run "rm -rf *.o" before the test scenario in original.
so when run llvm-ar -ma elf64.o archive.a xcoff64.o ,it will return
"xcoff64.o: No such file or directory"

but current we do not run "rm -rf *.o" before the

#RUN: llvm-ar -ma elf64.o archive.a xcoff64.o

there is xcoff64.o in the directory.
it return warning: 'xcoff64.o' is not valid with the current object file mode

I think we only to test the -X option work with -ma , so we need to xcoff64.o in the directory.

and from the logic for the llvm-ar.cpp it will check object file in the command line whether it exist first if we want to move the object file. it is logic is not new in the patch, so I do not think we need to test it.

181

sorry for the miss some of comment even I go the comment one by one.

[DiggerLin]

address comment

[jhenderson]

llvm/test/lit.cfg.py

481–487

Delete the blank line at the end of this comment. Also, some of the line wrapping is a bit off, so I recommend reflowing it.

llvm/test/tools/llvm-ar/option-X.test

78

Not addressed.

179

Thanks for the explanation - I didn't realise that the missing file was the one being added, which is indeed not something to do with this patch.

What happens if you try to move after a file with a bitness that doesn't match the object mode? That probably needs testing. I think there are two interesting cases: a) if there is only one object with the relevant name, and b) if there are two objects with the same name, but different bitness, where only the second one matches the object mode. The second case is unnecessary, if the first case's behaviour is that the object is moved to the right place anyway, even though the referenced object doesn't have the right object mode.

Outline example - update names of files as appropriate etc:

# Case 1:
llvm-ar rc -Xany archive.a xcoff64.o elf32.o elf64.o
llvm-ar ma -X64 elf32.o archive.a xcoff64.o

# Case 2, if case 1 is "elf32.o is treated as not present". First elf.o is 32-bits, second is 64.
llvm-ar rc -Xany archive.a xcoff64.o elf.o elf.o
llvm-ar ma -X64 elf.o archive.a xcoff64.o

[DiggerLin]

llvm/test/tools/llvm-ar/option-X.test

179

good catch, thanks. I add two more tests for it.

182

I change elf64.o --> elf32.o , otherwise it will return "error: insertion point not found"
that is not our test purpose for the scenario.

[jhenderson]

llvm/test/tools/llvm-ar/option-X.test

247

Typo in the file name? I assume it shouldn't be "xcoff64elf64.o"!

257–258

261

There's only one 32-bit xcoff.o. The "first" implied there was more.

273

[DiggerLin]

llvm/test/tools/llvm-ar/option-X.test

247

yes. it is Typo. I change to xcoff64.o,thanks.

[jhenderson]

Looks good from my point of view, but I'd like @gbreynoo to review the area highlighted earlier before this lands.

[gbreynoo]

llvm/tools/llvm-ar/llvm-ar.cpp

982

Can use warnInvalidObjectForFileMode.

[gbreynoo]

I think my comment got eaten. Sorry for the delay @jhenderson. I've had a look, particularly at the section highlighted, and I this is the best place for this check. The best I can suggest is the use of a lambda or new function to tidy the IA_AddNewMember and IA_MoveNewMember cases. Something like:

auto handleNewMembers = [&](auto Members, auto MemberI, auto Child) {
  NewArchiveMember NM = getArchiveMember(*MemberI);
  if (isValidInBitMode(NM))
    addMember(Members, NM);
  else {
    // If a new member is not a valid object for the bit mode, add the old
    // member back.
    warnInvalidObjectForFileMode(*MemberI);
    addChildMember(Members, Child,
                   /*FlattenArchive=*/Thin);
  }
};

So the calls sites are:

case IA_AddNewMember: {
  handleNewMembers(Ret, MemberI, Child);
} break;
case IA_MoveNewMember: {
  handleNewMembers(Moved, MemberI, Child);
} break;

How much clearer this is is debatable.

[DiggerLin]

address comment with a lambda function @gbreynoo

[gbreynoo]

Thanks that LGTM.

[barannikov88]

@DiggerLin
Could you check that llvm-ar can be built? I have a link-time error:

ld.lld: error: undefined symbol: llvm::MachO::is64Bit(llvm::MachO::Architecture)
>>> referenced by llvm-ar.cpp
>>>               tools/llvm-ar/CMakeFiles/llvm-ar.dir/llvm-ar.cpp.o:(isValidInBitMode(llvm::object::Binary&))

The symbol is defined in TextAPI component which llvm-ar does not depend on.

llvm/docs/CommandGuide/llvm-ar.rst

  When creating or modifying an archive, this option specifies that the
  ``archive`` will be thin. By default, archives are not created as thin archives
  and when modifying a thin archive, it will be converted to a regular archive.
 
 .. option:: --version
 
  Display the version of the :program:`llvm-ar` executable.
 
+.. option:: -X mode
+
+ Specifies the type of object file :program:`llvm-ar` will recognise. The mode must be
+ one of the following:
+
+   32
+         Process only 32-bit object files.
+   64
+         Process only 64-bit object files.
+   32_64
+         Process both 32-bit and 64-bit object files.
+   any
+         Process all object files.
+
+ The default is to process 32-bit object files (ignore 64-bit objects). The mode can also
+ be set with the OBJECT_MODE environment variable. For example, OBJECT_MODE=64 causes ar to
+ process any 64-bit objects and ignore 32-bit objects. The -X flag overrides the OBJECT_MODE
+ variable.
+
 .. option:: @<FILE>
 
   Read command-line options and commands from response file ``<FILE>``.
 
 MRI SCRIPTS
 -----------
 
 :program:`llvm-ar` understands a subset of the MRI scripting interface commonly

llvm/test/lit.cfg.py

for filename in os.listdir(dirname):
           if ('-emit-obj' in data or '-filetype=obj' in data) and '64' in config.target_triple:
             config.excludes += [ filename ]
        finally:
           f.close()
 
 if 'aix' in config.target_triple:
     for directory in ('/CodeGen/X86', '/DebugInfo', '/DebugInfo/X86', '/DebugInfo/Generic', '/LTO/X86', '/Linker'):
         exclude_unsupported_files_for_aix(config.test_source_root + directory)
+
+# Some tools support an environment variable "OBJECT_MODE" on AIX OS, which
+# controls the kind of objects they will support. If there is no "OBJECT_MODE"
+# environment variable specified, the default behaviour is to support 32-bit
+# objects only. In order to not affect most test cases, which expect to support
+# 32-bit and 64-bit objects by default, set the environment variable
+# "OBJECT_MODE" to 'any' by default on AIX OS.
+if 'system-aix' in config.available_features:
+    config.environment['OBJECT_MODE'] = 'any'

llvm/test/tools/llvm-ar/Inputs/bitcode-sym32.ll

+target triple = "powerpcle-unknown-linux-gnu"
+
+@C32 = dso_local global i32 5, align 4
+@undef_var32 = external dso_local global i32, align 4
+
+define dso_local i32 @foo32(i32 %i) #0 {
+entry:
+  %i.addr = alloca i32, align 4
+  store i32 %i, i32* %i.addr, align 4
+  %0 = load i32, i32* %i.addr, align 4
+  %1 = load i32, i32* @undef_var32, align 4
+  %add = add nsw i32 %0, %1
+  ret i32 %add
+}

llvm/test/tools/llvm-ar/Inputs/bitcode-sym64.ll

+target triple = "powerpc64le-unknown-linux-gnu"
+
+@C64 = dso_local global i32 5, align 4
+@static_var64 = internal global i32 2, align 4
+
+define dso_local signext i32 @bar64() #0 {
+entry:
+  %0 = load i32, i32* @static_var64, align 4
+  %1 = load i32, i32* @C64, align 4
+  %add = add nsw i32 %0, %1
+  ret i32 %add
+}

llvm/test/tools/llvm-ar/invalid-option-X.test

+# REQUIRES: !system-aix
+## Test that the -X option is not supported on non-AIX OS. 
+
+# RUN: not llvm-ar -q -X32 %t.a xcoff32.o  2>&1 | FileCheck %s
+# CHECK: error: -X32 option not supported on non AIX OS

llvm/test/tools/llvm-ar/option-X.test

+# REQUIRES: system-aix
+## Test the "-X" option.
+## The option specifies the type of object file llvm-ar will operate on.
+
+# RUN: rm -rf %t && mkdir %t && cd %t
+# RUN: unset OBJECT_MODE
+# RUN: yaml2obj --docnum=1 -DCLASS=ELFCLASS32 %s -o elf32.o
+# RUN: yaml2obj --docnum=1 -DCLASS=ELFCLASS64 %s -o elf64.o
+
+# RUN: yaml2obj --docnum=2 -DFLAG=0x1DF %s -o xcoff32.o
+# RUN: yaml2obj --docnum=2 -DFLAG=0x1F7 %s -o xcoff64.o
+
+## Test default -X option when creating a new archive.
+# RUN: llvm-ar -q -c archive-default.a xcoff32.o elf32.o xcoff64.o elf64.o  2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN-XCOFF64,WARN-ELF64
+# RUN: llvm-ar -t -Xany archive-default.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32
+
+## Test -X32 option when creating a new archive. 
+# RUN: llvm-ar -q -c -X 32 archive-32.a xcoff32.o elf32.o xcoff64.o elf64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN-XCOFF64,WARN-ELF64
+# RUN: llvm-ar -t -Xany archive-32.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32
+
+## Test -X option will override the "OBJECT_MODE" environment variable.
+# RUN: env OBJECT_MODE=64 llvm-ar -q -c -X32 archive-32-env1.a xcoff32.o elf32.o xcoff64.o elf64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN-XCOFF64,WARN-ELF64
+# RUN: llvm-ar -t -Xany archive-32-env1.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32
+
+# RUN: env OBJECT_MODE=32_64 llvm-ar -q -c -X32 archive-32-env2.a xcoff32.o elf32.o xcoff64.o elf64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN-XCOFF64,WARN-ELF64
+# RUN: llvm-ar -t -Xany archive-32-env2.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32
+
+# RUN: env OBJECT_MODE=any llvm-ar -q -c -X32 archive-32-env3.a xcoff32.o elf32.o xcoff64.o elf64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN-XCOFF64,WARN-ELF64
+# RUN: llvm-ar -t -Xany archive-32-env3.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32
+
+## Test -X64 option when creating a new archive.
+# RUN: llvm-ar -q -c -X 64 archive-64.a xcoff32.o elf32.o xcoff64.o elf64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN-XCOFF32,WARN-ELF32
+# RUN: llvm-ar -t -Xany archive-64.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ64
+
+## Test -X32_64 option when creating a new archive.
+## RUN: llvm-ar -q -c -X32_64 archive-32_64.a xcoff32.o elf32.o xcoff64.o elf64.o
+## RUN: llvm-ar -t -Xany archive-32_64.a | \
+## RUN:   FileCheck %s --check-prefixes=OBJ32_64
+
+## Test -Xany option when creating a new archive.
+# RUN: llvm-ar -q -c -Xany archive-any.a xcoff32.o elf32.o xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany archive-any.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32_64
+
+## Test envionment "OBJECT_MODE" when creating a new archive.
+# RUN: env OBJECT_MODE=32 llvm-ar -q -c archive-env32.a xcoff32.o elf32.o xcoff64.o elf64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN-XCOFF64,WARN-ELF64
+# RUN: llvm-ar -t -Xany archive-env32.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32
+
+# RUN: env OBJECT_MODE=64 llvm-ar -q -c archive-env64.a xcoff32.o elf32.o xcoff64.o elf64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN-XCOFF32,WARN-ELF32
+# RUN: llvm-ar -t -Xany archive-env64.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ64
+
+# RUN: env OBJECT_MODE=32_64 llvm-ar -q -c archive-env32_64.a xcoff32.o elf32.o xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany archive-env32_64.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32_64
+
+# RUN: env OBJECT_MODE=any llvm-ar -q -c archive-envany.a xcoff32.o elf32.o xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany archive-envany.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32_64
+
+## Test -X option for print operation.
+# RUN: llvm-ar -t archive-any.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32
+
+# RUN: llvm-ar -t -X32 archive-any.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32
+
+# RUN: llvm-ar -t -X64 archive-any.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ64
+
+# RUN: llvm-ar -t -X32_64 archive-any.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32_64
+
+# RUN: llvm-ar -t -Xany archive-any.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32_64
+
+## Test -X option for extract operation.
+# RUN: llvm-ar --output=32 -x -X32 archive-any.a
+# RUN: cmp xcoff32.o 32/xcoff32.o
+# RUN: cmp elf32.o 32/elf32.o
+# RUN: not ls 32/coff64.o
+# RUN: not ls 32/elf64.o
+
+# RUN: llvm-ar --output=64 -x -X64 archive-any.a
+# RUN: cmp xcoff64.o 64/xcoff64.o
+# RUN: cmp elf64.o 64/elf64.o
+# RUN: not ls 64/xcoff32.o
+# RUN: not ls 64/elf32.o
+
+# RUN: llvm-ar --output=32_64 -x -X32_64 archive-any.a
+# RUN: cmp xcoff32.o 32_64/xcoff32.o
+# RUN: cmp elf32.o 32_64/elf32.o
+# RUN: cmp xcoff64.o 32_64/xcoff64.o
+# RUN: cmp elf64.o 32_64/elf64.o
+
+# RUN: llvm-ar --output=any -x -Xany archive-any.a
+# RUN: cmp xcoff32.o any/xcoff32.o
+# RUN: cmp elf32.o any/elf32.o
+# RUN: cmp xcoff64.o any/xcoff64.o
+# RUN: cmp elf64.o any/elf64.o
+
+## Extract a 64-bit object file with option -X32 (or default object mode).
+# RUN: not llvm-ar --output=err64 -x archive-any.a xcoff64.o 2>&1 | \
+# RUN:   FileCheck %s -DFILE=xcoff64.o --check-prefixes=ERR64
+# RUN: not llvm-ar --output=err64 -x -X32 archive-any.a xcoff64.o 2>&1 | \
+# RUN:   FileCheck %s -DFILE=xcoff64.o --check-prefixes=ERR64
+
+# ERR64: llvm-ar: error: '[[FILE]]' was not found
+# RUN: not ls err64/xcoff64.o
+
+## Extract a 32-bit object file with option -X64.
+# RUN: not llvm-ar --output=err32 -x -X64 archive-any.a xcoff32.o 2>&1 | \
+# RUN:   FileCheck %s -DFILE=xcoff32.o --check-prefixes=ERR32
+
+# ERR32: llvm-ar: error: '[[FILE]]' was not found
+# RUN: not ls err32/xcoff32.o
+
+## Test deleting an object file from a big archive file.
+# RUN: cp archive-any.a archive.a
+# RUN: llvm-ar -d -X32 archive.a xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32_64
+
+# RUN: cp archive-any.a archive.a
+# RUN: llvm-ar -d -X64 archive.a xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32
+
+# RUN: cp archive-any.a archive.a
+# RUN: llvm-ar -d -Xany archive.a xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32
+ 
+# Test replace/insert an object file in a big archive file.
+# RUN: cp xcoff32.o xcoff.o
+# RUN: llvm-ar -q -c archive-rep.a xcoff.o
+
+## xcoff.o is a 64-bit object file here.
+# RUN: yaml2obj --docnum=2 -DFLAG=0x1F7 %s -o xcoff.o
+
+## Without -X64, -X32_64 or -Xany, nothing changed here,
+## since xcoff.o is a 64-bit object file in command line, but
+## the xcoff.o member in archive-rep.a is a 32-bit object file.
+# RUN: llvm-ar -r archive-rep.a xcoff.o
+# RUN: llvm-ar -t -Xany archive-rep.a | \
+# RUN:   FileCheck %s --check-prefixes=REP
+# RUN: llvm-nm -Xany --print-armap archive-rep.a | \
+# RUN:   FileCheck %s --check-prefixes=SYM32
+
+## With options -X64, -X32_64 or -Xany, the old 32-bit xcoff.o
+## member is still in the archive
+## and a new 64-bit object file xcoff.o is added to the archive.
+# RUN: llvm-ar -r -X64 archive-rep.a xcoff.o
+# RUN: llvm-ar -t -Xany archive-rep.a | \
+# RUN:   FileCheck %s --check-prefixes=REP,REP-DUP
+# RUN: llvm-nm -Xany --print-armap archive-rep.a | \
+# RUN:   FileCheck %s --check-prefixes=SYM32_64
+
+# REP:            xcoff.o
+# REP-DUP-NEXT:   xcoff.o
+# REP-EMPTY: 
+
+## Test move member.
+# RUN: cp archive-any.a archive.a
+## Do not move 64-bit object without options -X64, -X32_64, Xany.
+# RUN: llvm-ar -ma elf32.o archive.a xcoff64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=WARN-XCOFF64
+
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=OBJ32_64
+
+## Do not move 32-bit object with -X64.
+# RUN: llvm-ar -ma -X64 elf64.o archive.a xcoff32.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=WARN-XCOFF32
+
+# WARN-XCOFF32: warning: 'xcoff32.o' is not valid with the current object file mode
+# WARN-XCOFF64: warning: 'xcoff64.o' is not valid with the current object file mode
+# WARN-ELF32:   warning: 'elf32.o' is not valid with the current object file mode
+# WARN-ELF64:   warning: 'elf64.o' is not valid with the current object file mode
+
+# RUN: llvm-ar -ma -X64 elf64.o archive.a xcoff64.o
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=MOVE64
+
+# RUN: cp archive-any.a archive.a
+# RUN: llvm-ar -ma -X32_64 elf64.o archive.a xcoff64.o
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=MOVE64
+
+# RUN: cp archive-any.a archive.a
+# RUN: llvm-ar -ma -Xany elf64.o archive.a xcoff64.o
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=MOVE64
+
+# MOVE64:       xcoff32.o
+# MOVE64-NEXT:  elf32.o
+# MOVE64-NEXT:  elf64.o
+# MOVE64-NEXT:  xcoff64.o
+# MOVE64-EMPTY:
+
+# RUN: cp archive-any.a archive.a
+# RUN: llvm-ar -ma elf32.o archive.a xcoff32.o
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=MOVE32
+
+# RUN: cp archive-any.a archive.a
+# RUN: llvm-ar -ma -X32 elf32.o archive.a xcoff32.o
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=MOVE32
+
+# RUN: cp archive-any.a archive.a
+# RUN: llvm-ar -ma -X32_64 elf32.o archive.a xcoff32.o
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=MOVE32
+
+# RUN: cp archive-any.a archive.a
+# RUN: llvm-ar -ma -Xany elf32.o archive.a xcoff32.o
+# RUN: llvm-ar -t -Xany archive.a | \
+# RUN:   FileCheck %s --check-prefixes=MOVE32
+
+# MOVE32:       elf32.o
+# MOVE32-NEXT:  xcoff32.o
+# MOVE32-NEXT:  xcoff64.o
+# MOVE32-NEXT:  elf64.o
+# MOVE32-EMPTY:
+
+## Move after a file with a bitness that doesn't match the object mode.
+# RUN: not llvm-ar -ma xcoff64.o archive-any.a xcoff32.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=ERR-INSERT-POINT
+
+# RUN: not llvm-ar -X32 -ma xcoff64.o archive-any.a xcoff32.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=ERR-INSERT-POINT
+
+# RUN: not llvm-ar -X64 -ma xcoff32.o archive-any.a xcoff64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=ERR-INSERT-POINT
+
+# ERR-INSERT-POINT: error: insertion point not found
+
+## Test move operation for archive when there are two object files with 
+## the same name, but different bitness in archive.
+## There are two files named xcoff.o in archive-rep.a (the first one in
+## the archive is 32-bit, the second one is 64-bit).
+# RUN: cp archive-rep.a archive-rep-mov32.a
+# RUN: llvm-ar -Xany -q archive-rep-mov32.a elf32.o elf64.o
+## Move elf32.o to after the 32-bit xcoff.o.
+# RUN: llvm-ar -X32 -ma xcoff.o archive-rep-mov32.a elf32.o
+# RUN: llvm-ar -t -Xany archive-rep-mov32.a | \
+# RUN:   FileCheck %s --check-prefixes=MOVE32-DUP
+
+# MOVE32-DUP:         xcoff.o
+# MOVE32-DUP-NEXT:    elf32.o
+# MOVE32-DUP-NEXT:    xcoff.o
+# MOVE32-DUP-NEXT:    elf64.o
+
+# RUN: cp archive-rep.a archive-rep-mov64.a
+# RUN: llvm-ar -Xany -q archive-rep-mov64.a elf32.o elf64.o
+## Move elf64.o to after the 64-bit xcoff.o.
+# RUN: llvm-ar -X64 -ma xcoff.o archive-rep-mov64.a elf64.o
+# RUN: llvm-ar -t -Xany archive-rep-mov64.a | \
+# RUN:   FileCheck %s --check-prefixes=MOVE64-DUP
+
+# MOVE64-DUP:         xcoff.o
+# MOVE64-DUP-NEXT:    xcoff.o
+# MOVE64-DUP-NEXT:    elf64.o
+# MOVE64-DUP-NEXT:    elf32.o
+
+# OBJ32:          xcoff32.o
+# OBJ32-NEXT:     elf32.o
+# OBJ32-EMPTY:
+
+# OBJ64:        xcoff64.o
+# OBJ64-NEXT:   elf64.o
+# OBJ64-EMPTY:
+
+# OBJ32_64:       xcoff32.o
+# OBJ32_64-NEXT:  elf32.o
+# OBJ32_64-NEXT:  xcoff64.o
+# OBJ32_64-NEXT:  elf64.o
+# OBJ32_64-EMPTY:
+
+# SYM32:       var_0x1DF
+# SYM32-NOT:   var_0x1F7
+
+# SYM32_64:   var_0x1DF
+# SYM32_64:   var_0x1F7
+
+## Test -X option with other output formats. 
+
+# RUN: llvm-as -o 32.bc %p/Inputs/bitcode-sym32.ll
+# RUN: llvm-as -o 64.bc %p/Inputs/bitcode-sym64.ll
+# RUN: yaml2obj --docnum=3 %s -o macho32.o
+# RUN: yaml2obj --docnum=4 %s -o macho64.o
+# RUN: yaml2obj --docnum=5 %s -o wasm.o
+# RUN: yaml2obj --docnum=6 %s -o coff.o
+
+# RUN: llvm-ar -q -c archive-other32.a coff.o 32.bc 64.bc wasm.o macho32.o macho64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN-64
+# RUN: llvm-ar -t -Xany archive-other32.a | \
+# RUN:   FileCheck %s --check-prefixes=OTHER32
+
+# WARN-64:      warning: '64.bc' is not valid with the current object file mode
+# WARN-64-NEXT: warning: 'macho64.o' is not valid with the current object file mode
+
+# OTHER32:       coff.o
+# OTHER32-NEXT:  32.bc
+# OTHER32-NEXT:  wasm.o
+# OTHER32-NEXT:  macho32.o
+# OTHER32-EMPTY:
+
+# RUN: llvm-ar -q -c -X64 archive-other64.a coff.o 32.bc 64.bc wasm.o macho32.o macho64.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefixes=WARN-32
+# RUN: llvm-ar -t -Xany archive-other64.a | \
+# RUN:   FileCheck %s --check-prefixes=OTHER64
+
+# WARN-32:      warning: 'coff.o' is not valid with the current object file mode
+# WARN-32-NEXT: warning: '32.bc' is not valid with the current object file mode
+# WARN-32-NEXT: warning: 'wasm.o' is not valid with the current object file mode
+# WARN-32-NEXT: warning: 'macho32.o' is not valid with the current object file mode
+
+# OTHER64:      64.bc
+# OTHER64-NEXT: macho64.o
+# OTHER64-EMPTY:
+
+
+--- !ELF
+FileHeader:
+  Class:   [[CLASS]]
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+Symbols:
+  - Name:    [[CLASS]]_var
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       [[FLAG]]
+Symbols:
+  - Name:            var_[[FLAG]]
+
+--- !mach-o
+FileHeader:
+  magic:      0xFEEDFACE
+  cputype:    0x00000007
+  cpusubtype: 0x00000003
+  filetype:   0x00000001
+  ncmds:      0
+  sizeofcmds: 0
+  flags:      0x00002000
+
+## mach-o 64 bit
+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x0100000C
+  cpusubtype:      0x00000000
+  filetype:        0x00000001
+  ncmds:           0
+  sizeofcmds:      0
+  flags:           0x00000000
+  reserved:        0x00000000
+
+--- !WASM
+FileHeader:
+  Version: 0x00000001
+
+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_ARMNT
+  Characteristics: [  ]
+sections:
+symbols:

llvm/tools/llvm-ar/llvm-ar.cpp

 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ArchiveWriter.h"
+#include "llvm/Object/COFFImportFile.h"
+#include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolicFile.h"
+#include "llvm/Object/TapiFile.h"
+#include "llvm/Object/Wasm.h"
 #include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"

 #include <io.h>
 #endif
 
 #ifdef _WIN32
 #include "llvm/Support/Windows/WindowsSupport.h"
 #endif
 
 using namespace llvm;
+using namespace llvm::object;
 
 // The name this program was invoked as.
 static StringRef ToolName;
 
 // The basename of this program.
 static StringRef Stem;
 
 static void printRanLibHelp(StringRef ToolName) {
static void printArHelp(StringRef ToolName) {
   --plugin=<string>     - ignored for compatibility
   -h --help             - display this help and exit
   --output              - the directory to extract archive members to
   --rsp-quoting         - quoting style for response files
     =posix              -   posix
     =windows            -   windows
   --thin                - create a thin archive
   --version             - print the version and exit
+  -X{32|64|32_64|any}   - object mode (only for AIX OS)
   @<file>               - read options from <file>
 
 OPERATIONS:
   d - delete [files] from the archive
   m - move [files] in the archive
   p - print contents of [files] found in the archive
   q - quick append [files] to the archive
   r - replace or insert [files] into the archive
static void failIfError(Error E, Twine Context = "") {
   handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
     std::string ContextStr = Context.str();
     if (ContextStr.empty())
       fail(EIB.message());
     fail(Context + ": " + EIB.message());
   });
 }
 
+static void warn(Twine Message) {
+  WithColor::warning(errs(), ToolName) << Message << "\n";
+}
+
 static SmallVector<const char *, 256> PositionalArgs;
 
 static bool MRI;
 
 namespace {
 enum Format { Default, GNU, BSD, DARWIN, BIGARCHIVE, Unknown };
 }
 
enum ArchiveOperation {
   Move,            ///< Move members to end or as given by {a,b,i} modifiers
   QuickAppend,     ///< Quickly append to end of archive
   ReplaceOrInsert, ///< Replace or Insert members
   DisplayTable,    ///< Display the table of contents
   Extract,         ///< Extract files back to file system
   CreateSymTab     ///< Create a symbol table in an existing archive
 };
 
+enum class BitModeTy { Bit32, Bit64, Bit32_64, Any, Unknown };
+
+static BitModeTy BitMode = BitModeTy::Bit32;
+
 // Modifiers to follow operation to vary behavior
 static bool AddAfter = false;             ///< 'a' modifier
 static bool AddBefore = false;            ///< 'b' modifier
 static bool Create = false;               ///< 'c' modifier
 static bool OriginalDates = false;        ///< 'o' modifier
 static bool DisplayMemberOffsets = false; ///< 'O' modifier
 static bool CompareFullPath = false;      ///< 'P' modifier
 static bool OnlyUpdate = false;           ///< 'u' modifier
static bool shouldCreateArchive(ArchiveOperation Op) {
   case QuickAppend:
   case ReplaceOrInsert:
     return true;
   }
 
   llvm_unreachable("Missing entry in covered switch.");
 }
 
+static bool is64BitSymbolicFile(SymbolicFile &Obj) {
+  if (auto *IRObj = dyn_cast<IRObjectFile>(&Obj))
+    return Triple(IRObj->getTargetTriple()).isArch64Bit();
+  if (isa<COFFObjectFile>(Obj) || isa<COFFImportFile>(Obj))
+    return false;
+  if (XCOFFObjectFile *XCOFFObj = dyn_cast<XCOFFObjectFile>(&Obj))
+    return XCOFFObj->is64Bit();
+  if (isa<WasmObjectFile>(Obj))
+    return false;
+  if (TapiFile *Tapi = dyn_cast<TapiFile>(&Obj))
+    return Tapi->is64Bit();
+  if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
+    return MachO->is64Bit();
+  if (ELFObjectFileBase *ElfO = dyn_cast<ELFObjectFileBase>(&Obj))
+    return ElfO->getBytesInAddress() == 8;
+
+  fail("unsupported file format");
+}
+
+static bool isValidInBitMode(Binary &Bin) {
+  if (BitMode == BitModeTy::Bit32_64 || BitMode == BitModeTy::Any)
+    return true;
+
+  if (SymbolicFile *SymFile = dyn_cast<SymbolicFile>(&Bin)) {
+    bool Is64Bit = is64BitSymbolicFile(*SymFile);
+    if ((Is64Bit && (BitMode == BitModeTy::Bit32)) ||
+        (!Is64Bit && (BitMode == BitModeTy::Bit64)))
+      return false;
+  }
+  // In AIX "ar", non-object files are always considered to have a valid bit
+  // mode.
+  return true;
+}
+
+Expected<std::unique_ptr<Binary>> getAsBinary(const NewArchiveMember &NM,
+                                              LLVMContext *Context) {
+  auto BinaryOrErr = createBinary(NM.Buf->getMemBufferRef(), Context);
+  if (BinaryOrErr)
+    return std::move(*BinaryOrErr);
+  return BinaryOrErr.takeError();
+}
+
+Expected<std::unique_ptr<Binary>> getAsBinary(const Archive::Child &C,
+                                              LLVMContext *Context) {
+  return C.getAsBinary(Context);
+}
+
+template <class A> static bool isValidInBitMode(const A &Member) {
+  if (object::Archive::getDefaultKindForHost() != object::Archive::K_AIXBIG)
+    return true;
+  LLVMContext Context;
+  Expected<std::unique_ptr<Binary>> BinOrErr = getAsBinary(Member, &Context);
+  // In AIX "ar", if there is a non-object file member, it is never ignored due
+  // to the bit mode setting.
+  if (!BinOrErr) {
+    consumeError(BinOrErr.takeError());
+    return true;
+  }
+  return isValidInBitMode(*BinOrErr.get());
+}
+
+static void warnInvalidObjectForFileMode(Twine Name) {
+  warn("'" + Name + "' is not valid with the current object file mode");
+}
+
 static void performReadOperation(ArchiveOperation Operation,
                                  object::Archive *OldArchive) {
   if (Operation == Extract && OldArchive->isThin())
     fail("extracting from a thin archive is not supported");
 
   bool Filter = !Members.empty();
   StringMap<int> MemberCount;
   {
     Error Err = Error::success();
     for (auto &C : OldArchive->children(Err)) {
       Expected<StringRef> NameOrErr = C.getName();
       failIfError(NameOrErr.takeError());
       StringRef Name = NameOrErr.get();
 
+      // Check whether to ignore this object due to its bitness.
+      if (!isValidInBitMode(C))
+        continue;
+
       if (Filter) {
         auto I = find_if(Members, [Name](StringRef Path) {
           return comparePaths(Name, Path);
         });
         if (I == Members.end())
           continue;
         if (CountParam && ++MemberCount[Name] != CountParam)
           continue;
         Members.erase(I);
       }
 
       switch (Operation) {
       default:
         llvm_unreachable("Not a read operation");
       case Print:
         doPrint(Name, C);
         break;
if (!Thin || Lib.isThin()) {
       for (auto &Child : Lib.children(Err))
         addChildMember(Members, Child, /*FlattenArchive=*/Thin);
       failIfError(std::move(Err));
       return;
     }
   }
   Members.push_back(std::move(*NMOrErr));
 }
 
-static void addMember(std::vector<NewArchiveMember> &Members,
-                      StringRef FileName, bool FlattenArchive = false) {
+static NewArchiveMember getArchiveMember(StringRef FileName) {
   Expected<NewArchiveMember> NMOrErr =
       NewArchiveMember::getFile(FileName, Deterministic);
   failIfError(NMOrErr.takeError(), FileName);
   StringSaver Saver(Alloc);
   // For regular archives, use the basename of the object path for the member
   // name. For thin archives, use the full relative paths so the file resolves
   // correctly.
   if (!Thin) {
     NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName);
   } else {
     if (sys::path::is_absolute(FileName))
       NMOrErr->MemberName = Saver.save(sys::path::convert_to_slash(FileName));
     else {
       Expected<std::string> PathOrErr =
           computeArchiveRelativePath(ArchiveName, FileName);
       NMOrErr->MemberName = Saver.save(
           PathOrErr ? *PathOrErr : sys::path::convert_to_slash(FileName));
     }
   }
+  return std::move(*NMOrErr);
+}
+
+static void addMember(std::vector<NewArchiveMember> &Members,
+                      NewArchiveMember &NM) {
+  Members.push_back(std::move(NM));
+}
+
+static void addMember(std::vector<NewArchiveMember> &Members,
+                      StringRef FileName, bool FlattenArchive = false) {
+  NewArchiveMember NM = getArchiveMember(FileName);
+  if (!isValidInBitMode(NM)) {
+    warnInvalidObjectForFileMode(FileName);
+    return;
+  }
 
   if (FlattenArchive &&
-      identify_magic(NMOrErr->Buf->getBuffer()) == file_magic::archive) {
+      identify_magic(NM.Buf->getBuffer()) == file_magic::archive) {
     object::Archive &Lib = readLibrary(FileName);
     // When creating thin archives, only flatten if the member is also thin.
     if (!Thin || Lib.isThin()) {
       Error Err = Error::success();
       // Only Thin archives are recursively flattened.
       for (auto &Child : Lib.children(Err))
         addChildMember(Members, Child, /*FlattenArchive=*/Thin);
       failIfError(std::move(Err));
       return;
     }
   }
-  Members.push_back(std::move(*NMOrErr));
+  Members.push_back(std::move(NM));
 }
 
 enum InsertAction {
   IA_AddOldMember,
   IA_AddNewMember,
   IA_Delete,
   IA_MoveOldMember,
   IA_MoveNewMember
 };
 
 static InsertAction computeInsertAction(ArchiveOperation Operation,
                                         const object::Archive::Child &Member,
                                         StringRef Name,
                                         std::vector<StringRef>::iterator &Pos,
                                         StringMap<int> &MemberCount) {
+  if (!isValidInBitMode(Member))
+    return IA_AddOldMember;
+
   if (Operation == QuickAppend || Members.empty())
     return IA_AddOldMember;
   auto MI = find_if(
       Members, [Name](StringRef Path) { return comparePaths(Name, Path); });
 
   if (MI == Members.end())
     return IA_AddOldMember;
 
computeNewArchiveMembers(ArchiveOperation Operation,
   if (OldArchive) {
     Error Err = Error::success();
     StringMap<int> MemberCount;
     for (auto &Child : OldArchive->children(Err)) {
       int Pos = Ret.size();
       Expected<StringRef> NameOrErr = Child.getName();
       failIfError(NameOrErr.takeError());
       std::string Name = std::string(NameOrErr.get());
-      if (comparePaths(Name, RelPos)) {
+      if (comparePaths(Name, RelPos) && isValidInBitMode(Child)) {
         assert(AddAfter || AddBefore);
         if (AddBefore)
           InsertPos = Pos;
         else
           InsertPos = Pos + 1;
       }
 
       std::vector<StringRef>::iterator MemberI = Members.end();
       InsertAction Action =
           computeInsertAction(Operation, Child, Name, MemberI, MemberCount);
+
+      auto HandleNewMember = [](auto Member, auto &Members, auto &Child) {
+        NewArchiveMember NM = getArchiveMember(*Member);
+        if (isValidInBitMode(NM))
+          addMember(Members, NM);
+        else {
+          // If a new member is not a valid object for the bit mode, add
+          // the old member back.
+          warnInvalidObjectForFileMode(*Member);
+          addChildMember(Members, Child, /*FlattenArchive=*/Thin);
+        }
+      };
+
       switch (Action) {
       case IA_AddOldMember:
         addChildMember(Ret, Child, /*FlattenArchive=*/Thin);
         break;
       case IA_AddNewMember:
-        addMember(Ret, *MemberI);
+        HandleNewMember(MemberI, Ret, Child);
         break;
       case IA_Delete:
         break;
       case IA_MoveOldMember:
         addChildMember(Moved, Child, /*FlattenArchive=*/Thin);
         break;
       case IA_MoveNewMember:
-        addMember(Moved, *MemberI);
+        HandleNewMember(MemberI, Moved, Child);
         break;
       }
       // When processing elements with the count param, we need to preserve the
       // full members list when iterating over all archive members. For
       // instance, "llvm-ar dN 2 archive.a member.o" should delete the second
       // file named member.o it sees; we are not done with member.o the first
       // time we see it in the archive.
       if (MemberI != Members.end() && !CountParam)
         Members.erase(MemberI);
     }
     failIfError(std::move(Err));
   }
 
   if (Operation == Delete)
     return Ret;
 
static int performOperation(ArchiveOperation Operation,
 
   assert(EC == errc::no_such_file_or_directory);
 
   if (!shouldCreateArchive(Operation)) {
     failIfError(EC, Twine("unable to load '") + ArchiveName + "'");
   } else {
     if (!Create) {
       // Produce a warning if we should and we're creating the archive
-      WithColor::warning(errs(), ToolName)
-          << "creating " << ArchiveName << "\n";
+      warn("creating " + ArchiveName);
     }
   }
 
   performOperation(Operation, nullptr, nullptr, NewMembers);
   return 0;
 }
 
 static void runMRIScript() {
static bool handleGenericOption(StringRef arg) {
   }
   if (arg == "--version") {
     cl::PrintVersionMessage();
     return true;
   }
   return false;
 }
 
+static BitModeTy getBitMode(const char *RawBitMode) {
+  return StringSwitch<BitModeTy>(RawBitMode)
+      .Case("32", BitModeTy::Bit32)
+      .Case("64", BitModeTy::Bit64)
+      .Case("32_64", BitModeTy::Bit32_64)
+      .Case("any", BitModeTy::Any)
+      .Default(BitModeTy::Unknown);
+}
+
 static const char *matchFlagWithArg(StringRef Expected,
                                     ArrayRef<const char *>::iterator &ArgIt,
                                     ArrayRef<const char *> Args) {
   StringRef Arg = *ArgIt;
 
   if (Arg.startswith("--"))
     Arg = Arg.substr(2);
 

 }
 
 static int ar_main(int argc, char **argv) {
   SmallVector<const char *, 0> Argv(argv + 1, argv + argc);
   StringSaver Saver(Alloc);
 
   cl::ExpandResponseFiles(Saver, getRspQuoting(makeArrayRef(argv, argc)), Argv);
 
+  // Get BitMode from enviorment variable "OBJECT_MODE" for AIX OS, if
+  // specified.
+  if (object::Archive::getDefaultKindForHost() == object::Archive::K_AIXBIG) {
+    BitMode = getBitMode(getenv("OBJECT_MODE"));
+    if (BitMode == BitModeTy::Unknown)
+      BitMode = BitModeTy::Bit32;
+  }
+
   for (ArrayRef<const char *>::iterator ArgIt = Argv.begin();
        ArgIt != Argv.end(); ++ArgIt) {
     const char *Match = nullptr;
 
     if (handleGenericOption(*ArgIt))
       return 0;
     if (strcmp(*ArgIt, "--") == 0) {
       ++ArgIt;
if ((Match = matchFlagWithArg("output", ArgIt, Argv))) {
       OutputDir = Match;
       continue;
     }
 
     if (matchFlagWithArg("plugin", ArgIt, Argv) ||
         matchFlagWithArg("rsp-quoting", ArgIt, Argv))
       continue;
 
+    if (strncmp(*ArgIt, "-X", 2) == 0) {
+      if (object::Archive::getDefaultKindForHost() ==
+          object::Archive::K_AIXBIG) {
+        Match = *(*ArgIt + 2) != '\0' ? *ArgIt + 2 : *(++ArgIt);
+        BitMode = getBitMode(Match);
+        if (BitMode == BitModeTy::Unknown)
+          fail(Twine("invalid bit mode: ") + Match);
+        continue;
+      } else {
+        fail(Twine(*ArgIt) + " option not supported on non AIX OS");
+      }
+    }
+
     Options += *ArgIt + 1;
   }
 
   ArchiveOperation Operation = parseCommandLine();
   return performOperation(Operation, nullptr);
 }
 
 static int ranlib_main(int argc, char **argv) {