[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

294

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"?

303

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

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

620

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

636

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

641

This would be a more normal way of calling it.

646–647

651

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

652

Delete the extra blank line.

657–658

Same comment change request as above.

673

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.

700–701

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.

770–773

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.

1212

Please make this function name conform to LLVM style.

1270

1272

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

1274

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).

1328–1329

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

1333

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

1336

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

620

thanks, change to is64BitSymbolicFile

636

thanks

641

thanks

651

thanks

700–701

good catch, thanks

770–773

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.

1212

thanks

1274

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

1328–1329

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

2

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

633

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.

666–667

I think this phrasing is a little cleaner.

689

699

Delete this unrelated change.

805

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.

915

@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.

919

1328–1329

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.

1333

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

670–671

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.

805

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.

919–923

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

670–671

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

805

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

919–923

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

682

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

482–488 ↗

(On Diff #444109)

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

931

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/Object/X86/archive-symbol-table.s

+# RUN: export "OBJECT_MODE=any"
 # RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 # RUN: rm -f %t
 # RUN: llvm-ar rcs %t %t.o
 # RUN: llvm-nm --print-armap %t | FileCheck %s
 
 # Test that weak undefined symbols don't show up in the archive symbol
 # table.
 
 .global foo

llvm/test/Object/archive-symtab.test

+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj --docnum=1 %s -o %t.elf-x86-64
 # RUN: yaml2obj --docnum=2 %s -o %t2.elf-x86-64
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL

llvm/test/tools/llvm-ar/add-library.test

+RUN: export "OBJECT_MODE=any"
 RUN: yaml2obj %S/Inputs/add-lib1.yaml -o %t-add-lib1.o
 RUN: yaml2obj %S/Inputs/add-lib2.yaml -o %t-add-lib2.o
 RUN: yaml2obj %S/Inputs/add-lib2.yaml -o %t-add-lib3.o
 
 RUN: rm -f %t.ar
 RUN: llvm-ar crs %t.ar %t-add-lib1.o
 RUN: llvm-ar cqs %t.ar %t-add-lib2.o
 

llvm/test/tools/llvm-ar/default-add.test

+RUN: export "OBJECT_MODE=any"
 RUN: yaml2obj %S/Inputs/macho.yaml -o %t-macho.o
 RUN: yaml2obj %S/Inputs/coff.yaml -o %t-coff.o
 RUN: yaml2obj %S/Inputs/elf.yaml -o %t-elf.o
 
 RUN: rm -f %t.ar
 RUN: llvm-ar crs %t.ar %t-macho.o
 RUN: grep -q __.SYMDEF %t.ar
 
 RUN: rm -f %t.ar
 RUN: llvm-ar crs %t.ar %t-coff.o
 RUN: not grep -q __.SYMDEF %t.ar
 RUN: llvm-ar crs %t.ar %t-macho.o
 RUN: not grep -q __.SYMDEF %t.ar
 RUN: llvm-ar crs %t.ar %t-elf.o
 RUN: not grep -q __.SYMDEF %t.ar
 
 RUN: rm -f %t.ar
 Test with the options in a different order.
 RUN: llvm-ar rsc %t.ar %t-macho.o
-RUN: grep -q __.SYMDEF %t.ar
+RUN: grep -q __.SYMDEF %t.ar
 

llvm/test/tools/llvm-ar/default-macho.test

+RUN: export "OBJECT_MODE=any"
 RUN: yaml2obj %S/Inputs/macho.yaml -o %t.o
 
 RUN: rm -f %t.ar
 RUN: llvm-ar crs %t.ar %t.o
 RUN: grep -q __.SYMDEF %t.ar
 
 Ensure that we generate a BSD style archive for MachO by default.  ld64 expects
 that it will be in BSD format.
 

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

+# REQUIRES: !system-aix
+## Test not support "-X" option in no AIX OS 
+
+# RUN: not llvm-ar -q -X32 %t.a xcoff32.o  2>&1 | \
+# RUN:   FileCheck %s  --check-prefixes=ERR
+# ERR: error: -X32 option not supported on non AIX OS 

llvm/test/tools/llvm-ar/macho-edit.test

 ## Make sure the darwin format specifics are preserved when updating archives.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: yaml2obj %p/Inputs/macho.yaml > %t/dup.o
 
 ## Create the archive with a duplicate object to ensure that darwin specific
 ## incrementing timestamps are used.
 # RUN: llvm-ar --format=darwin crD %t/lib.a %t/dup.o %t/dup.o
 # RUN: cp %t/lib.a %t/lib.copy.a
 
 ## Replace an object file in the archive to force a re-write.
 # RUN: llvm-ar crD %t/lib.a %t/dup.o
 # RUN: obj2yaml %t/lib.a | FileCheck --implicit-check-not=LastModified %s
 
 # CHECK: LastModified: '1'
 # CHECK: LastModified: '2'

llvm/test/tools/llvm-ar/move.test

 ## Test the move command without modifiers moves members to the end
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: yaml2obj %s -o %t/1.o --docnum=1
 # RUN: yaml2obj %s -o %t/2.o --docnum=2
 # RUN: yaml2obj %s -o %t/3.o --docnum=3
 
 ## Move single member:
 # RUN: llvm-ar rc %t/single.a %t/1.o %t/2.o %t/3.o
 # RUN: llvm-ar m %t/single.a %t/1.o

llvm/test/tools/llvm-ar/mri-addlib.test

 ## Test the ADDLIB MRI command.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: yaml2obj %s -o %t/f.o
 # RUN: llvm-ar r %t/f.a %t/f.o
 
 ## Merge contents of archives.
 # RUN: echo "CREATE %t/addlib.a" > %t/addlib.mri
 # RUN: echo "ADDLIB %t/f.a" >> %t/addlib.mri
 # RUN: echo "SAVE" >> %t/addlib.mri

llvm/test/tools/llvm-ar/mri-addmod.test

 ## Test the ADDMOD MRI command.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: yaml2obj %s -o %t/f.o
 
 # RUN: echo "CREATE %t/addmod.a" > %t/addmod.mri
 # RUN: echo "ADDMOD %t/f.o" >> %t/addmod.mri
 # RUN: echo "SAVE" >> %t/addmod.mri
 # RUN: llvm-ar -M < %t/addmod.mri
 # RUN: llvm-nm --print-armap %t/addmod.a | FileCheck %s

llvm/test/tools/llvm-ar/mri-comments.test

 # Test different MRI comment formats and white space.
 
+RUN: export "OBJECT_MODE=any"
 RUN: rm -rf %t && mkdir -p %t
 RUN: yaml2obj %S/Inputs/elf.yaml -o %t/elf.o
 
 RUN: echo "create %t/mri.ar;comment" > %t/script.mri
 RUN: echo "addmod %t/elf.o * comment" >> %t/script.mri
 RUN: echo "; comment" >> %t/script.mri
 RUN: echo " ;comment" >> %t/script.mri
 RUN: echo "* comment" >> %t/script.mri

llvm/test/tools/llvm-ar/mri-end.test

 # The END MRI command is optional. Scripts that omit
 # or include END should be handled by llvm-ar.
+RUN: export "OBJECT_MODE=any"
 RUN: rm -rf %t && mkdir -p %t
 
 # Empty File
 RUN: yaml2obj %S/Inputs/elf.yaml -o %t/elf.o
 
 RUN: touch %t/empty.mri
 RUN: llvm-ar -M < %t/empty.mri
 

llvm/test/tools/llvm-ar/mri-thin-archive.test

+RUN: export "OBJECT_MODE=any"
 RUN: rm -rf %t && mkdir -p %t/addlib/
 
 RUN: yaml2obj %S/Inputs/elf.yaml -o %t/elf.o
 RUN: cp %t/elf.o %t/addlib/elf.o
 RUN: cp %t/elf.o %t/delete.o
 
 RUN: cd %t && llvm-ar rTc addlib/addlib.ar addlib/elf.o
 

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

+# REQUIRES: system-aix
+## Test the "-X" option.
+## The option specifies the type of object file to be operate in llvm-ar.
+
+# RUN: rm -rf %t
+# RUN: mkdir %t
+# RUN: cd %t
+# 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 -X option for the create a new archive operation 
+# RUN: rm -f %t.a
+# RUN: llvm-ar -q -c %t.a xcoff32.o elf32.o xcoff64.o elf64.o 2>&1 | \
+# RUN:   FileCheck %s  --check-prefixes=INFO_64
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32
+
+# INFO_64: xcoff64.o is not valid with the current object file mode.
+# INFO_64: elf64.o is not valid with the current object file mode.
+
+# RUN: rm -f %t32.a
+# RUN: llvm-ar -q -c -X 32 %t32.a xcoff32.o elf32.o xcoff64.o elf64.o 2>&1
+# RUN: llvm-ar -t -Xany %t32.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32
+
+# RUN: rm -f %t.a
+# RUN: export "OBJECT_MODE=64"
+# RUN: llvm-ar -q -c -X32 %t.a xcoff32.o elf32.o xcoff64.o elf64.o
+# unset OBJECT_MODE
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32
+
+# RUN: rm -f %t.a
+# RUN: llvm-ar -q -c -X 64 %t.a xcoff32.o elf32.o xcoff64.o elf64.o 2>&1 | \
+# RUN:  FileCheck %s  --check-prefixes=INFO_32
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ64
+
+# INFO_32: xcoff32.o is not valid with the current object file mode.
+# INFO_32: elf32.o is not valid with the current object file mode.
+
+# RUN: rm -f %t.a
+# RUN: export "OBJECT_MODE=64"
+# RUN: llvm-ar -q -c  %t.a xcoff32.o elf32.o xcoff64.o elf64.o 
+# RUN: unset OBJECT_MODE
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ64
+
+# RUN: rm -f %t.a
+# RUN: llvm-ar -q -c -Xany %t.a xcoff32.o elf32.o xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32_64
+
+# RUN: rm -f %t.a
+# RUN: llvm-ar -q -c -X32_64 %t.a xcoff32.o elf32.o xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32_64
+
+# RUN: rm -f %t.a
+# RUN: export "OBJECT_MODE=32_64" 
+# RUN: llvm-ar -q -c  %t.a xcoff32.o elf32.o xcoff64.o elf64.o
+# RUN: unset OBJECT_MODE
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32_64
+
+# RUN: rm -f %t.a
+# RUN: export "OBJECT_MODE=any"
+# RUN: llvm-ar -q -c  %t.a xcoff32.o elf32.o xcoff64.o elf64.o
+# RUN: unset OBJECT_MODE
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32_64
+
+## Test -X option for print operation.
+
+# RUN: llvm-ar -t -X32 %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32
+
+# RUN: llvm-ar -t -X64 %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ64
+
+# RUN: llvm-ar -t -X32_64 %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32_64
+
+## Test -X option for extract operation.
+# RUN: rm -rf *.o
+# RUN: llvm-ar -x -X32 %t.a
+# RUN: test -f xcoff32.o
+# RUN: test -f elf32.o
+# RUN: not test -f xcoff64.o
+# RUN: not test -f elf64.o
+
+# RUN: rm -rf *.o
+# RUN: llvm-ar -x -X64 %t.a
+# RUN: test -f xcoff64.o
+# RUN: test -f elf64.o
+# RUN: not test -f xcoff32.o
+# RUN: not test -f elf32.o
+
+# RUN: rm -rf *.o
+# RUN: llvm-ar -x -X32_64 %t.a
+# RUN: test -f xcoff32.o
+# RUN: test -f elf32.o
+# RUN: test -f xcoff64.o
+# RUN: test -f elf64.o
+
+# RUN: rm -rf *.o
+# RUN: llvm-ar -x -Xany %t.a
+# RUN: test -f xcoff32.o
+# RUN: test -f elf32.o
+# RUN: test -f xcoff64.o
+# RUN: test -f elf64.o
+
+## Extract a 64bit object file with option -X32
+# RUN: rm -rf *.o
+# RUN: not llvm-ar -x %t.a xcoff64.o 2>&1 | \
+# RUN:   FileCheck %s  -DFILE=xcoff64.o --check-prefixes=ERR64
+# RUN: not llvm-ar -x -X32 %t.a xcoff64.o 2>&1 | \
+# RUN:   FileCheck %s  -DFILE=xcoff64.o --check-prefixes=ERR64
+
+# ERR64: llvm-ar: error: '[[FILE]]' was not found
+# RUN: not test -f xcoff64.o
+
+## Test deleting a object file from big archive file.
+# RUN: cp %t.a %t_bak.a
+# RUN: llvm-ar -d -X32  %t.a xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32_64
+
+# RUN: cp %t_bak.a %t.a
+# RUN: llvm-ar -d -X64  %t.a xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32
+
+# RUN: cp %t_bak.a %t.a
+# RUN: llvm-ar -d -Xany  %t.a xcoff64.o elf64.o
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32
+ 
+## Test replace/insert a object file from big archive file.
+## xcoff32.o is 64 bits object file here. without -X64 or -X32_64
+# RUN: rm -rf *.o
+# RUN: yaml2obj --docnum=2 -DFLAG=0x1F7 %s -o xcoff32.o
+
+## Without  -X64, -X32_64 or -Xany, nothing changed here,
+## since xcoff32.o is 64 bits object file.
+# RUN: llvm-ar -ru %t32.a xcoff32.o
+# RUN: llvm-ar -t -Xany %t32.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32
+# RUN: llvm-nm -Xany --format=just-symbols %t32.a | \
+# RUN:   FileCheck %s --check-prefixes=SYM32
+
+## With option -X64, -X32_64 or -Xany, 
+## the old 32bit xcoff32.o is still in the archive 
+## and a new 64bits object file is added into the archive. 
+# RUN: llvm-ar -ru -X64 %t32.a xcoff32.o
+# RUN: llvm-ar -t -Xany %t32.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32,OBJ32_DUP
+# RUN: llvm-nm -Xany --format=just-symbols %t32.a | \
+# RUN:   FileCheck %s --check-prefixes=SYM32_64
+
+## Test move mumber
+# RUN: cp %t_bak.a %t.a
+## Not move 64bits object without -X64
+# RUN: not llvm-ar -ma elf64.o %t.a xcoff64.o 2>&1| \
+# RUN:   FileCheck %s  --check-prefixes=MOVE_ERR
+
+# MOVE_ERR: llvm-ar: error: xcoff64.o: No such file or directory
+
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=OBJ32_64
+
+# RUN: llvm-ar -ma -X64  elf64.o %t.a xcoff64.o
+# RUN: llvm-ar -t -Xany %t.a | \
+# RUN:   FileCheck %s  --check-prefixes=MOVE
+# MOVE:       xcoff32.o
+# MOVE-NEXT:  elf32.o
+# MOVE-NEXT:  elf64.o
+# MOVE-NEXT:  xcoff64.o
+# MOVE-EMPTY: 
+
+#OBJ32:          xcoff32.o 
+#OBJ32-NEXT:     elf32.o
+#OBJ32_DUP-NEXT: xcoff32.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
+
+
+--- !ELF
+FileHeader:
+  Class:   [[CLASS]]
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+Symbols:
+  - Name:    [[CLASS]]_var
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       [[FLAG]]
+Symbols:
+  - Name:            var_[[FLAG]]
+

llvm/test/tools/llvm-ar/quick-append.test

 ## Test quick append 
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: yaml2obj %s -o %t/1.o --docnum=1
 # RUN: yaml2obj %s -o %t/2.o --docnum=2
 
 ## Append single member:
 # RUN: llvm-ar qc %t/single.a %t/1.o
 # RUN: llvm-ar t %t/single.a \
 # RUN:   | FileCheck %s --check-prefix=SINGLE --match-full-lines --implicit-check-not {{.}}

llvm/test/tools/llvm-ar/reduce-thin-path.test

+RUN: export "OBJECT_MODE=any"
 RUN: rm -rf %t && mkdir -p %t/foo/bar/
 RUN: mkdir -p %t/baz/
 RUN: yaml2obj %S/Inputs/elf.yaml -o %t/elf.o
 
 RUN: cd %t && llvm-ar rTc %t/baz/internal.ar elf.o
 RUN: cd %t/foo && llvm-ar rTc %t/foo/bar/external.ar ../baz/internal.ar
 
 RUN: FileCheck -input-file=%t/foo/bar/external.ar %s
 
 CHECK: {{^}}../../elf.o/

llvm/test/tools/llvm-ar/regex-cmd.test

+RUN: export "OBJECT_MODE=any"
 RUN: yaml2obj %S/Inputs/elf.yaml -o %t.o
 
 RUN: rm -f %t.ar
 RUN: llvm-ar crs %t.ar %t.*
 RUN: llvm-ar tv %t.ar | FileCheck %s
 
 CHECK: regex-cmd.test{{.*}}.o

llvm/test/tools/llvm-ar/replace-update.test

 ## Test that the replace command with "u" updates the relevant members.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -rf %t && mkdir -p %t/new/other
 
 # RUN: yaml2obj %s -o %t/1.o --docnum=1
 # RUN: yaml2obj %s -o %t/2.o --docnum=2
 # RUN: yaml2obj %s -o %t/3.o --docnum=3
 
 # RUN: env TZ=GMT touch -t 200001020304 %t/1.o
 # RUN: env TZ=GMT touch -t 200001020304 %t/2.o

llvm/test/tools/llvm-ar/replace.test

 ## Test the replace command without modifiers replaces the relevant members.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -rf %t && mkdir -p %t/new/other
 # RUN: yaml2obj %s -o %t/1.o --docnum=1
 # RUN: yaml2obj %s -o %t/2.o --docnum=2
 # RUN: yaml2obj %s -o %t/3.o --docnum=3
 
 # RUN: yaml2obj %s -o %t/new/1.o --docnum=4
 # RUN: yaml2obj %s -o %t/new/3.o --docnum=5
 

llvm/test/tools/llvm-ar/symtab.test

 ## Test the s and S modifiers. Build and do not build a symbol table.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %s -o %t.o
 # RUN: touch %t-other.txt
 
 ## Default:
 # RUN: rm -f %t-default.a
 # RUN: llvm-ar rc %t-default.a %t.o
 # RUN: llvm-nm --print-armap %t-default.a \
 # RUN:   | FileCheck %s --check-prefix=SYMTAB

llvm/test/tools/llvm-ar/thin-archive.test

+RUN: export "OBJECT_MODE=any"
 RUN: rm -rf %t && mkdir -p %t/foo/bar/
 
 RUN: yaml2obj %S/Inputs/elf.yaml -o %t/foo/elf.o
 RUN: cp %t/foo/elf.o %t/foo/bar/elf.o
 RUN: cp %t/foo/bar/elf.o %t/delete.o
 
 Test that modules can be added with absolute paths when the archive is created using an absolute path
 

llvm/test/tools/llvm-dwarfdump/X86/section_sizes_archive.test

 ## Check how llvm-dwarfdump calculates section sizes
 ## with --show-section-sizes on an archive.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: yaml2obj --docnum=1 %s -o %t/1.o
 # RUN: yaml2obj --docnum=2 %s -o %t/2.o
 
 # RUN: rm -f %t.a
 # RUN: llvm-ar rc %t.a %t/1.o %t/2.o
 
 # RUN: llvm-dwarfdump --show-section-sizes %t.a \

llvm/test/tools/llvm-libtool-darwin/L-and-l.test

 ## This test checks that -l and -L options work correctly.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
 # RUN: yaml2obj %S/Inputs/input2.yaml -o %t-input2.o
 
 ## Check that the library is recognised when it ends with '.o':
 # RUN: llvm-libtool-darwin -static -o %t.lib -l%basename_t.tmp-input1.o -l%basename_t.tmp-input2.o -L%T
 # RUN: llvm-ar t %t.lib | \
 # RUN:   FileCheck %s --check-prefix=CHECK-NAMES --implicit-check-not={{.}} -DPREFIX=%basename_t.tmp
 # RUN: llvm-nm --print-armap %t.lib | \

llvm/test/tools/llvm-libtool-darwin/archive-flattening.test

 ## This test checks that an archive is flattened correctly.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
 # RUN: yaml2obj %S/Inputs/input2.yaml -o %t-input2.o
 # RUN: llvm-as %S/Inputs/x86_64-osx.ll -o %t-x86_64.bc
 
 ## Input a correct archive:
 # RUN: rm -f %t.correct.ar
 # RUN: llvm-ar cr %t.correct.ar %t-x86_64.bc %t-input1.o %t-input2.o
 # RUN: llvm-libtool-darwin -static -o %t.lib %t.correct.ar

llvm/test/tools/llvm-libtool-darwin/cpu-subtype-matching.test

 ## This test checks that the CPU subtype matching logic is handled correctly.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %s --docnum=1 -o %t-armv6.obj
 # RUN: yaml2obj %s --docnum=2 -o %t-armv7.obj
 # RUN: llvm-as %p/Inputs/arm64-ios.ll -o %t-arm64.bc
 # RUN: llvm-as %p/Inputs/armv7-ios.ll -o %t-armv7.bc
 
 # RUN: llvm-libtool-darwin -static -o %t.lib %t-armv6.obj %t-armv7.obj %t-arm64.bc %t-armv7.bc -arch_only armv7
 
 ## Check that only armv7 binary is present:

llvm/test/tools/llvm-libtool-darwin/create-static-lib.test

 ## This test checks that a correct static library is created.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
 # RUN: yaml2obj %S/Inputs/input2.yaml -o %t-input2.o
 # RUN: llvm-as %S/Inputs/x86_64-osx.ll -o %t-x86_64.bc
 
 # RUN: rm -rf %t.lib %t2.lib
 # RUN: llvm-libtool-darwin -static -o %t.lib %t-input1.o %t-input2.o %t-x86_64.bc
 # RUN: llvm-libtool-darwin -static -o %t2.lib -o %t.lib %t-input1.o %t-input2.o %t-x86_64.bc
 # RUN: not ls %t2.lib

llvm/test/tools/llvm-libtool-darwin/deterministic-library.test

 ## This test checks that timestamps are set to 0 by default or when the -D
 ## option is specified, and that they are preserved when the -U option is
 ## specified.
 ## We only test timestamps as a proxy for full deterministic writing; i.e. we
 ## assume UID/GIDs are preserved if timestamps are preserved.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
 # RUN: touch -t 199505050555.55 %t-input1.o
 
 ## Test values are set to 0 (by default):
 # RUN: llvm-libtool-darwin -static -o %t.lib %t-input1.o
 # RUN: env TZ=GMT llvm-ar tv %t.lib | FileCheck %s --check-prefix=CHECK-DETERMINISTIC
 
 ## Test values are set to 0 (with -D):

llvm/test/tools/llvm-libtool-darwin/filelist.test

 ## This test checks that the -filelist option works correctly.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
 # RUN: yaml2obj %S/Inputs/input2.yaml -o %t-input2.o
 # RUN: llvm-as %S/Inputs/x86_64-osx.ll -o %t-x86_64.bc
 
 ## Passing files in a listfile:
 # RUN: echo %t-input1.o >  %t.files.txt
 # RUN: echo %t-input2.o >> %t.files.txt
 # RUN: echo %t-x86_64.bc >> %t.files.txt

llvm/test/tools/llvm-libtool-darwin/universal-object-flattening.test

 ## This test checks that a universal object file is flattened correctly.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %s -o %t-universal.o
 # RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
 # RUN: yaml2obj %S/Inputs/input2.yaml -o %t-input2.o
 
 # RUN: llvm-libtool-darwin -static -o %t.lib %t-universal.o -arch_only arm64
 
 ## Check that the binary is present:
 # RUN: llvm-ar t %t.lib | \

llvm/test/tools/llvm-lipo/create-archive-input.test

+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %p/Inputs/i386-slice.yaml -o %t-i386.o
 # RUN: yaml2obj %p/Inputs/x86_64-slice.yaml -o %t-x86_64.o
 # RUN: yaml2obj %p/Inputs/i386-x86_64-universal.yaml -o %t-universal.o
 # RUN: llvm-as %p/Inputs/armv7-ios.ll -o %t-ir-armv7.o
 # RUN: llvm-as %p/Inputs/x64-osx.ll -o %t-ir-x86_64.o
 
 # RUN: llvm-ar cr %t.empty.a
 # RUN: not llvm-lipo %t.empty.a -create -output /dev/null 2>&1 | FileCheck --check-prefix=EMPTY-ARCHIVE %s

llvm/test/tools/llvm-nm/X86/archive-no-llvm-bc.test

+; RUN: export "OBJECT_MODE=any"
 ; RUN: rm -rf %t && mkdir -p %t
 ; RUN: grep -v "module asm" %s | llvm-as -o %t/embedded.bc
 ; RUN: llc -I=%t -filetype=obj -o %t/obj.o %s
 ; RUN: llvm-ar crs %t/lib.a %t/obj.o
 ; RUN: llvm-nm -m --no-llvm-bc %t/lib.a | FileCheck %s
 
 target triple = "x86_64-apple-macosx10.11"
 
 @q = global i32 1, align 4
 ; CHECK-NOT: {{-+}} (LTO,DATA) external _q
 ; CHECK: {{[[:xdigit:]]+}} (__DATA,__data) external _q
 
 module asm ".section __LLVM,__bitcode"
 module asm ".incbin \22embedded.bc\22"
 

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

 ## Test the "-X" option.
 ## The option specifies the type of object file to examine.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: llvm-as -o %t32.bc %p/Inputs/bitcode-sym32.ll
 # RUN: llvm-as -o %t64.bc %p/Inputs/bitcode-sym64.ll
 
 # RUN: llvm-nm --format=just-symbols -X32 %t32.bc %t64.bc | \
 # RUN:   FileCheck %s -DFILE1=%t32.bc --check-prefixes=BITCODE32 --implicit-check-not={{.}}
 # RUN: llvm-nm --format=just-symbols -X64 %t32.bc %t64.bc | \
 # RUN:   FileCheck %s -DFILE2=%t64.bc --check-prefixes=BITCODE64 --implicit-check-not={{.}}
 # RUN: llvm-nm --format=just-symbols %t32.bc %t64.bc | \

llvm/test/tools/llvm-objcopy/ELF/basic-archive-copy.test

+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %s -o %t
 
 # RUN: rm -f %t.a
 # RUN: llvm-ar crs %t.a %t
 # RUN: cp %t.a %t.copy.a
 # RUN: llvm-objcopy %t.a %t2.a
 # RUN: llvm-objcopy %t %t2
 # RUN: llvm-ar p %t2.a > %t3

llvm/test/tools/llvm-objcopy/ELF/deterministic-archive.test

+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %s -o %t.o
 
 # Create an archive, specifying U so that timestamps/etc. are preserved.
 # We only test timestamps as a proxy for full deterministic writing; i.e. we
 # assume UID/GIDs are preserved if timestamps are preserved.
 # RUN: touch -t 199505050555.55 %t.o
 # RUN: rm -f %t.a
 # RUN: llvm-ar crsU %t.a %t.o

llvm/test/tools/llvm-objcopy/ELF/strip-all.test

+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %s -o %t
 # RUN: cp %t %t3
 # RUN: llvm-objcopy --strip-all %t %t2
 # RUN: llvm-readobj --file-headers --sections %t2 | FileCheck %s
 
 # Verify that the previous llvm-objcopy's run has not modified the input.
 # RUN: cmp %t %t3
 

llvm/test/tools/llvm-objcopy/ELF/strip-debug.test

+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %s -o %t
 # RUN: cp %t %t3
 # RUN: llvm-objcopy --strip-debug %t %t2
 # RUN: llvm-readobj --file-headers --sections --symbols %t2 | FileCheck %s
 
 # Verify that the previous run of llvm-objcopy has not modified the input.
 # RUN: cmp %t %t3
 

llvm/test/tools/llvm-objcopy/MachO/archive-format.test

 # REQUIRES: x86-registered-target
 
 ## Make sure the darwin format specifics are preserved when updating archives.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %p/Inputs/macho.64.s -o %t/dup.o
 # RUN: llvm-ar --format=darwin crD %t/lib.a %t/dup.o %t/dup.o
 # RUN: llvm-objcopy %t/lib.a %t/lib.copy.a
 # RUN: obj2yaml %t/lib.copy.a | FileCheck --implicit-check-not=LastModified %s
 
 # CHECK: LastModified: '1'
 # CHECK: LastModified: '2'

llvm/test/tools/llvm-objdump/X86/disassemble-archive-with-source.ll

 ; This test checks that 'llvm-objdump --source' works with archive files.
 ; The reason this test is written in .ll is that showing source code
 ; requires the debug data to have the source file path. Since we create
 ; the source file ad-hoc in this test, we don't know the path beforehand to
 ; create the object and archive.
 
+; RUN: export "OBJECT_MODE=any"
 ; RUN: rm -rf %t && mkdir -p %t/subdir && cd %t
 ; RUN: echo -e "int foo(int a)\n\n{ return a+1; }" > subdir/a.c
 ; RUN: sed -e "s,DIRNAME,%/t/subdir," %s | llc --filetype=obj -mtriple=x86_64-pc-linux -o a.o
 ; RUN: llvm-ar rc a.a a.o
 ; RUN: rm a.o
 ; RUN: llvm-objdump --source a.a | FileCheck %s
 
 ; CHECK: { return a+1; }

llvm/test/tools/llvm-objdump/X86/warn-missing-disasm-func.test

 ## Warn if --disassemble-symbols specifies an unknown symbol.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj -o %t.o %s
 # RUN: rm -f %t.a
 # RUN: llvm-ar qc %t.a %t.o %t.o
 # RUN: llvm-objdump --disassemble-symbols=foo %t.o 2>&1 | FileCheck %s
 # RUN: llvm-objdump --disassemble-symbols=foo %t.a 2>&1 | FileCheck %s --check-prefix=MULTI
 
 --- !ELF
 FileHeader:

llvm/test/tools/llvm-objdump/all-headers.test

+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objdump --all-headers %t | FileCheck %s
 # RUN: llvm-objdump -x %t | FileCheck %s
 
 ## Note: --all-headers (-x) is an alias for --archive-headers --file-headers
 ## --section-headers --private-headers --reloc --syms (-afhprt). Test for them
 ## in the following order which provides GNU objdump compatability.
 

llvm/test/tools/llvm-objdump/warn-missing-section.test

 ## This test checks the warning message when no user specified sections are
 ## found in the object file.
 
+# RUN: export "OBJECT_MODE=any"
+
 ## Test relocatable file.
 # RUN: yaml2obj --docnum=1 %s -o %t.1.o
 # RUN: yaml2obj --docnum=2 %s -o %t.2.o
 
 ## - Warn for one section is found case.
 # RUN: llvm-objdump --reloc --section=single %t.2.o 2>&1 \
 # RUN:   | FileCheck --check-prefix=SINGLE-WARN %s
 

llvm/test/tools/llvm-ranlib/D-flag.test

 ## Test the -D and -U flags of llvm-ranlib
 ## Create an archive with timestamps but without symbol table
 ## Important: all `llvm-ar tv` calls must use TZ=UTC to produce identical values
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %S/../llvm-ar/Inputs/add-lib1.yaml -o %t.o
 # RUN: env TZ=UTC touch -t 200001020304 %t.o
 # RUN: rm -f %t.a %t-no-index.a && llvm-ar cqSU %t-no-index.a %t.o
 
 ## Check that the intial listing has real values:
 # RUN: env TZ=UTC llvm-ar tv %t-no-index.a | FileCheck %s --check-prefix=REAL-VALUES
 
 ## Check that the -D flag clears the timestamps:

llvm/test/tools/llvm-readobj/ELF/file-summary-json.test

 ## Test how we output JSON file summaries.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -rf %t.dir
 # RUN: mkdir -p %t.dir
 # RUN: yaml2obj %s -o %t.dir/obj
 
 ## Test outputting file summary for a single file.
 # RUN: llvm-readobj --elf-output-style=JSON --pretty-print %t.dir/obj | \
 # RUN:   FileCheck %s --check-prefix=SINGLE \
 # RUN:     --match-full-lines --strict-whitespace --implicit-check-not={{.}}

llvm/test/tools/llvm-readobj/ELF/stack-sizes.test

 ## Check that we correctly display the contents of the .stack_sizes section
 ## in a relocatable object file.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj --docnum=1 %s -o %t01
 # RUN: llvm-readelf --stack-sizes %t01 \
 # RUN:   | FileCheck %s --check-prefix=RELOC-GNU --strict-whitespace --match-full-lines
 # RUN: llvm-readobj --stack-sizes %t01 | FileCheck %s --check-prefix=RELOC-LLVM
 
 #      RELOC-GNU:         Size     Functions
 # RELOC-GNU-NEXT:           16     referenced_by_symbol_foo
 # RELOC-GNU-NEXT:           32     referenced_via_section_bar

llvm/test/tools/llvm-readobj/ELF/wrong-shstrtab-type.test

 ## Check we do not fail to dump the section headers when
 ## a .shstrtab section does not have a SHT_STRTAB type.
 
 ## Check we report only one warning for the issue for each input object.
-
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %s -o %t1
 # RUN: llvm-readobj -S %t1 2>&1 | FileCheck %s -DFILE=%t1 --implicit-check-not warning --check-prefix LLVM
 # RUN: llvm-readelf -S %t1 2>&1 | FileCheck %s -DFILE=%t1 --implicit-check-not warning --check-prefix GNU
 
 # LLVM: warning: '[[FILE]]': invalid sh_type for string table section [index 1]: expected SHT_STRTAB, but got SHT_PROGBITS
 # LLVM:  Section {
 # LLVM:    Name: .shstrtab
 # LLVM:    Type: SHT_PROGBITS

llvm/test/tools/llvm-readobj/archive.test

 ## Test how we dump archives.
 
 ## Show that dumping operations apply to all members in an archive.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -f %t.a
 # RUN: rm -rf %t.dir
 # RUN: mkdir -p %t.dir
 # RUN: yaml2obj --docnum=1 %s -o %t.dir/trivial.obj.elf-x86-64
 # RUN: yaml2obj --docnum=2 %s -o %t.dir/trivial.obj.elf-i386
 # RUN: yaml2obj --docnum=3 %s -o %t.dir/trivial.obj.coff-arm
 
 # RUN: llvm-ar rc %t.a %t.dir/trivial.obj.elf-x86-64 %t.dir/trivial.obj.elf-i386 %t.dir/trivial.obj.coff-arm

llvm/test/tools/llvm-readobj/thin-archive.test

+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -f %t.a
 # RUN: rm -rf %t
 # RUN: mkdir -p %t
 # RUN: yaml2obj --docnum=1 %s -o %t/1.o
 # RUN: yaml2obj --docnum=2 %s -o %t/2.o
 # RUN: yaml2obj --docnum=3 %s -o %t/3.o
 # RUN: llvm-ar rcT %t.a %t/1.o %t/2.o %t/3.o
 

llvm/test/tools/llvm-size/archive.test

 ## Show how llvm-size behaves when passed in an archive.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: yaml2obj %s --docnum=1 -o %t1
 # RUN: yaml2obj %s --docnum=2 -o %t2
 
 ## Case 1: Empty archive. No output expected.
 # RUN: rm -f %t1.a
 # RUN: llvm-ar rc %t1.a
 
 # RUN: llvm-size -B %t1.a | count 0

llvm/test/tools/llvm-size/totals.test

 ## Show that llvm-size prints the total sizes when --totals is specified.
 
+# RUN: export "OBJECT_MODE=any"
 # RUN: rm -f %t.a
 # RUN: yaml2obj %s --docnum=1 -o %t.o
 # RUN: yaml2obj %s --docnum=2 -o %t2.o
 # RUN: llvm-ar rc %t.a %t.o %t2.o
 # RUN: llvm-size --totals %t.o %t.a %t2.o \
 # RUN:   | FileCheck %s -DFILE1=%t.o -DFILE2=%t2.o -DARCHIVE=%t.a
 # RUN: llvm-size -t %t.o %t.a %t2.o \
 # RUN:   | FileCheck %s -DFILE1=%t.o -DFILE2=%t2.o -DARCHIVE=%t.a

llvm/test/tools/llvm-tli-checker/multi-file.yaml

 ## Test that we can pass multiple files. There are several ways to do this:
 ## list them all individually, use --libdir to shorten the list, or use a
 ## response file (with or without --libdir).
 ##
 # REQUIRES: x86-registered-target
 #
+# RUN: export "OBJECT_MODE=any"
 # RUN: mkdir -p %t.dir
 # RUN: yaml2obj --docnum=1 %s -o %t.dir/file1
 # RUN: yaml2obj --docnum=2 %s -o %t.dir/file2
 # RUN: yaml2obj --docnum=3 %s -o %t.dir/file3
 
 # RUN: llvm-tli-checker --triple x86_64-scei-ps4 --report=full \
 # RUN:     %t.dir/file1 %t.dir/file2 %t.dir/file3 | \
 # RUN:   FileCheck %s

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) {
--format              - archive format to create
     =aix                -   aix (big archive)
   --plugin=<string>     - ignored for compatibility
   -h --help             - display this help and exit
   --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
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();
+  return cast<ELFObjectFileBase>(Obj).getBytesInAddress() == 8;
+}
+
+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) {
+  auto BinaryOrErr = createBinary(NM.Buf->getMemBufferRef());
+  if (BinaryOrErr)
+    return std::move(*BinaryOrErr);
+  return BinaryOrErr.takeError();
+}
+
+Expected<std::unique_ptr<Binary>> getAsBinary(const Archive::Child &C) {
+  return C.getAsBinary();
+}
+
+template <class A> static bool isValidInBitMode(const A &Member) {
+  if (object::Archive::getDefaultKindForHost() != object::Archive::K_AIXBIG)
+    return true;
+  Expected<std::unique_ptr<Binary>> BinOrErr = getAsBinary(Member);
+  // In AIX "ar", If there is member which is not a object file, it also always
+  // be consider as valid bit mode.
+  if (!BinOrErr) {
+    consumeError(BinOrErr.takeError());
+    return true;
+  }
+  return isValidInBitMode(*BinOrErr.get());
+}
+
 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 the object mode is permit to output.
+      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);
if (!Thin || Lib.isThin()) {
         addChildMember(Members, Child, /*FlattenArchive=*/Thin);
       failIfError(std::move(Err));
       return;
     }
   }
   Members.push_back(std::move(*NMOrErr));
 }
 
-static void addMember(std::vector<NewArchiveMember> &Members,
+// If the Members is valid object mode, push back into 'Members' and return
+// true; otherwise do not push back into 'Members' and return false.
+static bool addMember(std::vector<NewArchiveMember> &Members,
                       StringRef FileName, bool FlattenArchive = false) {
   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) {
if (FlattenArchive &&
     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;
+      return true;
     }
   }
+
+  if (isValidInBitMode(*NMOrErr)) {
     Members.push_back(std::move(*NMOrErr));
+    return true;
+  }
+
+  outs() << NMOrErr->MemberName.str()
+         << " is not valid with the current object file mode.\n";
+  return false;
 }
 
 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;
 
for (auto &Child : OldArchive->children(Err)) {
       std::vector<StringRef>::iterator MemberI = Members.end();
       InsertAction Action =
           computeInsertAction(Operation, Child, Name, MemberI, MemberCount);
       switch (Action) {
       case IA_AddOldMember:
         addChildMember(Ret, Child, /*FlattenArchive=*/Thin);
         break;
       case IA_AddNewMember:
-        addMember(Ret, *MemberI);
+        if (!addMember(Ret, *MemberI))
+          // If a new member is not a valid object mode, add old member back.
+          addChildMember(Ret, Child, /*FlattenArchive=*/Thin);
         break;
       case IA_Delete:
         break;
       case IA_MoveOldMember:
         addChildMember(Moved, Child, /*FlattenArchive=*/Thin);
         break;
       case IA_MoveNewMember:
-        addMember(Moved, *MemberI);
+        if (!addMember(Moved, *MemberI))
+          // If a new member is not a valid object mode, move old member.
+          addChildMember(Moved, Child, /*FlattenArchive=*/Thin);
         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 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) {
         fail(std::string("Invalid format ") + 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(std::string("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) {