[AIX] Support of Big archive (read)

[DiggerLin]

Summary

The patch is based on the EGuesnet's implement of the "Support of Big archive (read)
the first commit of the patch is come from https://reviews.llvm.org/D100651.

the rest of commits of the patch

1  Addressed the comments on the https://reviews.llvm.org/D100651
2  according to https://www.ibm.com/docs/en/aix/7.2?topic=formats-ar-file-format-big

using the "fl_fstmoff" for the first object file number, using "char ar_nxtmem[20]" to get next object file , using the "char fl_lstmoff[20]" for the last of the object file will fix the following problems:

  
   2.1 can not correct reading a archive files which has padding data between too object file
   2.2 can not correct reading a archive files from which some object file has be deleted
 
3 introduce a new derived class BigArchive for big ar file.

[jhenderson]

llvm/lib/Object/Archive.cpp

712

Make Ret a unique_ptr<Archive> and use std::make_unique here and below. Otherwise, you have a memory leak if Err is reported.

745–750

Stare at this code a minute and see if you can spot the bug... (hint, what is the value of Format before and after if this is a BigArchive?)

1191

Change this name. Do you understand what the variable is supposed to represent, because this name makes me think you don't...?

1196

There are still unnecessary braces in this if.

llvm/test/Object/archive-big-extract.test

3

Get rid of the extra spaces, although actually I think you should do the cd on the same line as the directory creation.

llvm/test/Object/archive-big-print.test

2–3

The comment markers aren't necessary yet, but in a future version, where you create the inputs on the fly via yaml2obj etc, you will need them.

No need for --check-prefix when there's only one FileCheck run in a file: use just the default instead.

llvm/test/Object/archive-big-read.test

1

In the future, the input will hopefully be generated on the fly rather than using a canned binary.

Also, add comment markers and don't use check-prefix, as above.

llvm/test/tools/llvm-objdump/XCOFF/archive-headers.test

1

See my earlier comment re. let's not add this test just yet (we don't want to add binaries to the git repo if we can avoid it, and I think testing it should be in all tools that can take a Big Archive, once we have write support).

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

1013

I think you can get rid of this blank line.

[DiggerLin]

llvm/lib/BinaryFormat/Magic.cpp

95

I will remove the change from the patch, the change do not need from the patch, it will need on when I will implement the change in the create export list.

llvm/lib/Object/Archive.cpp

111

it can not put into the base class constructor , for the definition of ArMemHdrType is different in the BigArchiveMemberHeader and ArchiveMemberHeader.

268–271

after address the comment, the getRawName , maybe return a Error.

342–352

it can not pushed into the base class and pass in the pointer to get offset from.

When you call from the Child , for example
Header->getOffset()
Header is AbstractArchiveMemberHeader, it do not have ArMemHdr

354–363

the ArMemHdr are defined different in the ArchiveMemberHeader and BigArchiveMemberHeader to use a function to take the raw string of AccessMode.

379–387

I have think over to use a common function before. but
for the definition of ArMemHdr is different in ArchiveMemberHeader and BigArchiveMemberHeader , it is difficult to put into a common.

a lot of duplicated code are caused by the same reason.
If change the name of ArMemHdr in the BigArchiveMemberHeader to "BigArMemHdr " , it maybe be more easy to understand the reason.

[DiggerLin]

address comment

[DiggerLin]

llvm/include/llvm/Object/Archive.h

147

I will create another patch for it.

[jhenderson]

I've stopped reviewing partway through this. There are a number of my previous comments that you've marked as done but haven't been addressed. Can you confirm that you've updated this to the latest diff you'd like me to review, please, before I proceed further?

llvm/include/llvm/Object/Archive.h

63

This has been marked as done, but isn't addressed in the latest diff. Please don't mark things as done until they've been addressed in an uploaded diff (if you select the Mark as Done checkbox, in the UI, and then upload the diff, the checked boxes will be submitted automatically when you upload the diff).

65

Also, does this need to be public? It wasn't before...

This bit hasn't been addressed.

104

If I'm not mistaken, "aix" is usually written as "AIX", so we should do the same here (I may easily be wrong though).

114–123

I'd group these accessor functions as getRaw... in one block, and then get... (without raw) in another block, with a blank line separating teh two. I'd also suggest ordering within the blocks to match each other, as close as practical.

125

Marked as Done but not addressed.

387

Please address all clang-format problems in your modified/new code.

llvm/lib/Object/Archive.cpp

55

1. Lower-camel-case names for functions.
2. "create" is a more common term than "generate" for these sort of functions.

58

Is this safe and correct given that this has been done at the start of the calling code too?

60–61

Make this a StringRef (or event a Twine I believe would work), rather than std::string.

63–68

I believe if you flip these around, you can do the suggested inline edit. Also note I added the braces for the old else (now the new if part), as I believe the consensus is that if you use braces for an if, you should for all its corresponding else parts too (and vice versa).

76

I don't believe you need this if anymore, right?

111

Isn't that what the getSizeOf function is for?

112

I don't believe you need this if anymore?

125

Marked as done, but not addressed.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

65

from the https://llvm.org/doxygen/Archive_8cpp_source.html line 361
uint64_t Size = Header.getSizeOf();
it should be public.

It wasn't before..

the getSizeOf() is public too in the original code.

104

thanks

llvm/lib/Object/Archive.cpp

58

I can not get the comment , I am appreciate that if you can you explain more detail on it.

60–61

thanks

63–68

thanks

76

yes, there is if (Err) check in the createMemberHeaderParseError

745–750

  } else if (Buffer.startswith(BigMagic)) {
    Format = K_AIXBIG;
    IsThin = false;
    return;
}

for BigArchive, there is "return;" in the BigArchive, it will not come here.

[jhenderson]

I've spent far more time than I've got reviewing this patch today. I'll have to leave reviewing it further for a while yet.

llvm/include/llvm/Object/Archive.h

37

Whilst looking at the later points, it occurred to me that we could solve some of the duplication, by doing something like the following:

1. Change AbstractArchiveMemberHeader to take a template parameter, namely the underlying ArMemHdrType used in the subclasses.
2. Have the concrete classes pass in their private member type as the template parameter.
3. Create a new base class, that AbstractArchiveMemberHeader<T> inherits from.
4. Push the virtual interface into that class.
5. Move the functions that are duplicated in the two subclasses into the templated class. The subclasses should then only contain the sets of functions that actually have to be different, as opposed to just needing to be different due to neeeding to have slightly different template classes.

What do you think? Going with this approach, I'd suggest names like ArMemberHeaderInterface, and AbstractArMemberHeader, but other name ideas are welcome.

54–56

I'm not sure why you've moved this function: it's not really anything to do wtih a member function's properties. Put it back where it was in the original source code.

124–127

These functions aren't properties of the member header (i.e. they don't correspond to fields in that header). I'd keep them separate from the other batch, with a blank line. Same goes for the regular archive version.

169

Please remember to clang-format your changes.

llvm/lib/Object/Archive.cpp

56

"Ar" is a more common abbreviation for "Archive" than "Arc"

58

I'm not too familiar with how ErrorAsOutParameter works, but the calling site for this function also has an ErrorAsOutParameter. As a result, the Err has been put inside more than one of these objects, which seems suspicious to me. It may not be safe (e.g. it might assert).

That being said, why not just have this function return an Error always, and go back to checking whether the function returned an Error::success() at the call sites? The name of this function implies an Error is created always.

109

Why is this not done in the initializer list, like the regular archive header class?

161

The regular archive kind has various safety checks to make sure the number read makes sense. For example, it checks to make sure there's actually a number in the field. We also need to show that the name's start and end are within the archive buffer, otherwise we'll get crashes/reading past the end of the file etc.

This hasn't been addressed. Why not?

287

Please run clang-tidy on your code changes, as I'm finding a number of mistakes like this that should have been caught before this patch was put up for review.

342–352

Apologies, I think you misunderstood me, possibly I wasn't clear enoguh.

How about the following concrete points:

1. Add a virtual function to AbstractArchiveMemberHeader called getData() or similar.
2. Implement this concrete function in the two subclasses, to return reinterpret_cast<const char *>(ArMemHdr).
3. Don't make getOffset a virtual function, and instead implement it solely in the base class as follows:

uint64_t AbstractArchiveMemberHeader::getOffset() const {
  return getData() - Parent->getData().data();
}

372

379–387

I've got no issue with BigArMemHdr as a name, if you prefer it. I don't think it makes a great deal of difference to my points though.

398

Use a (potentially templated) function, not a macro. This macro does nothing beneficial that a function can't do.

745–750

Fair point, but then the addition to the comment is either wrong or in the wrong location, since it talks about Big Archives, but is referring to code that happens earlier.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

37

I think your method call "Curiously recurring template pattern" (abbr as CRTP), I have considerate the method before. but I give up when I tried to implement it. The reason as

1. Using CRTP, it will create two different base class AbstractArchiveMemberHeader after template instantiation . there is no abstract class for both ArchiveMemberHeader and BigArchiveMemberHeader , if there is no common abstract class.

How do we deal with

std::unique_ptr<AbstractArchiveMemberHeader> Header;

in

class Child {
  friend Archive;
  friend AbstractArchiveMemberHeader;

  const Archive *Parent;
  std::unique_ptr<AbstractArchiveMemberHeader> Header;
  /// Includes header but not padding byte.
  StringRef

using a template too ?

[jhenderson]

llvm/include/llvm/Object/Archive.h

37

It's similar to CRTP, but isn't CRTP. CRTP is when a class passes itself as a template parameter, e.g.

class Derived : public Base<Derived> {};

You've missed in my suggestion the addition of an additional base class. Here's a sketch of what I mean:

// Base interface. Refer to this in client code.
class ArchiveMemberHeaderInterface {
  // pure virtual functions only
};

// Templated helper class for common functionality
template <typename FormatSpecificHeader>
class AbstractArchiveMemberHeader : public ArchiveMemberHeaderInterface {
  // concrete common functions
};

class ArchiveMemberHeader : public AbstractArchiveMemberHeader<ArMemHdrType> {
  // implementations of format-specific functionality
};

class BigArchiveMemberHeader : public AbstractArchiveMemberHeader<BigArMemHdrType> {
};

See points 3 and 4 above. Nothing would ever directly reference AbstractArchiveMemberHeader directly, except in that inheritance.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

37

I think I got your suggestion.

[DiggerLin]

llvm/lib/Object/Archive.cpp

56

thanks

58

having this function return an Error always is good idea , thanks.

342–352

using the The curiously recurring template pattern (CRTP) .

398

for the T is not type , it is concrete field of the ArMemHdrType , it can not be templated function.

[DiggerLin]

using Curiously recurring template pattern to reduce duplicate function code and address other comments

[DiggerLin]

llvm/lib/Object/Archive.cpp

398

for example :

#include <stdio.h>
struct T {
 char V[80];
};

T t= { {0} };

template <class T>
int getSize(T m) {
  printf(" size of =%u \n", sizeof(m));
  return sizeof(m);
}

int main() {
 getSize(t.V);
 return 0;
}
~

bash> clang++ t.cpp
t.cpp:10:29: warning: format specifies type 'int' but the argument has type 'unsigned long' [-Wformat]

printf(" size of =%d \n", sizeof(m));
                  ~~      ^~~~~~~~~
                  %lu

t.cpp:15:2: note: in instantiation of function template specialization 'getSize<char *>' requested here
getSize(t.V);
^
1 warning generated.
^
1 warning generated.
-bash-4.2$ ./a.out
size of =8

the size is wrong.
~

[jhenderson]

llvm/include/llvm/Object/Archive.h

35–39

Rather than putting these in a new archive namespace (and then not putting the rest of the archive code in that namespace...), I'd suggest renaming the variables, and leaving them in the object namespace directly. Suggested names would be "ArchiveMagic", "ThinArchiveMagic", and "BigArchiveMagic" (optionally using "Ar" instead of "Archive", if you want something more succinct).

59

Thanks for the class restructuring. I hope you agree that it looks better not having the duplicated code.

I think the class name needs changing. Apart from anything else, the name says nothing about archives. I also don't think "FieldAPI" makes a huge amount of sense to me (I see what you're trying to do though). I have two possible alternatives:

1. My preferred approach would be to rename ArchiveMemberHeader to UnixArchiveMemberHeader, and then use ArchiveMemberHeader for this class's name.
2. If renaming the ArchiveMemberHeader touches too much code, I'd suggest renaming this class to CommonArchiveMemberHeader.

Abbreviating "Archive" to "Ar" and "Member" to "Mem" is okay, in either case.

Additionally, you haven't got it quite right: the T parameter here should be the current T::ArMemHdrType instead, with the ArMemHdr being passed into this class's constructor (and potentially the instance in the derived clas isn't needed). That'll avoid the need for a) the friend declarations (I believe), and b) the need to repeatedly do const T &DerivedMemberHeader = static_cast<const T &>(*this); in the get* methods.

76

No need for virtual here. Just delete it.

382

Still need to clang-foramt some of this content, it looks like.

llvm/lib/Object/Archive.cpp

70

Continuing our discussion that has now moved too far from the relevant site. As these fields are char arrays, you should be able to do something like:

template <class T, std::size_t N>
StringRef getFieldRawString(const T (&Field)[N]) {
  return StringRef(Field, N).rtrim(" ");
}

This will populate the template parameter N with the char array size, using template auto-deduction, avoiding the need for the sizeof entirely. See how the std::size signature works in C++17 for an example of this (note that obviously we don't want to use std::size itself here).

199–200

I've fixed some grammar issues, and also suggested a slight improvement to the name terminator, to use the actual ASCII representations, for ease of understanding.

204

Any reason this can't be StringRef NameTerminator = "\n`?

I'd also put it before the NameStringWithNameTerminator, and you can then use NameTerminator.size() to set the length for NameStringWithNameTerminator

210–212

Could you not use createMemberHeaderParseError rather than calling malformedError directly here?

454–456

This padding is in a couple of different places now. I think it would be good to move it into a small helper function, called e.g. makeEven.

That being said, there are some functions elsewhere within LLVM that align things (see "alignTo"). Could you use that instead. here and in similar places?

465–466

I think this comment is superfluous: the code is fairly clear as to what it does.

734–739

I believe you can use sizeof instead of strlen here, as the magic strings are char arrays, rather than pointers. Please double-check though.

1194

Here and below, should this be "AIX" in the error message?

llvm/test/Object/archive-big-extract.test

3

Why hasn't this been addressed yet?

3

As noted already, this test, in its current form, isn't about extracting the archive contents, so it should be renamed, and comments/names updated accordingly, e.g. archive-big-print.test (note that the -p option is for printing a member, not extracting it). Adding a -x test case is a tangential thing, which can be added either as part of this test case, or separately, I don't mind.

llvm/test/Object/archive-big-print.test

2–3

Any reason this hasn't been addressed yet?

llvm/test/Object/archive-big-read.test

1

Also, add comment markers and don't use check-prefix, as above.

This hasn't been addressed.

[DiggerLin]

llvm/lib/Object/Archive.cpp

70

thanks

[DiggerLin]

llvm/include/llvm/Object/Archive.h

35–39

thanks

59

if change ArchiveMemberHeader -> UnixArchiveMemberHeader
I think we need to change Archive to UnixAchive too at this moment, changing Archive to UnixAchive will cause a lot of llvm-* file changing. (I think we need another separate patch for changing Archive to UnixAchive later).
I am prefer method 2 now.

Additionally, you haven't got it quite right: the T parameter here should be the current T::ArMemHdrType instead, with the ArMemHdr being passed into this class's constructor (and potentially the instance in the derived clas isn't needed). That'll avoid the need for a) the friend declarations (I believe), and b) the need to repeatedly do const T &DerivedMemberHeader = static_cast<const T &>(*this); in the get* methods.

I do not think I can do as your suggestion, for example : the
ArchiveMemberHeader are not instantiated complete, ArchiveMemberHeader::ArMemHdrType will be incomplete type.

you can try to compile the code

class AbstractArchiveMemberHeader {
};

template <typename T>
class CommonArchiveMemberHeader : public AbstractArchiveMemberHeader {
 T *a;
}

class ArchiveMemberHeader
    : public CommonArchiveMemberHeader<ArchiveMemberHeader::A> {

 struct A {
  };
}

class BigArchiveMemberHeader
    : public CommonArchiveMemberHeader<BigArchiveMemberHeader::A> {
   struct A {
  };
}

you will get error when compile

76

It need virtual here

in the function Archive::Child::Child(const Archive *Parent, const char *Start, Error *Err)

: Parent(Parent)

{
....
uint64_t Size = Header->getSizeOf();
...}

llvm/lib/Object/Archive.cpp

204

thanks

210–212

I think we present a more specific error information here than using createMemberHeaderParseError.

734–739

use sizeof will have one more bytes than strlen() , for the sizeof also include "\0" in the string.

llvm/test/Object/archive-big-extract.test

3

the test case using option -x to extract the member file out the archive. and compare the file content, why we need to change the name to archive-big-print.test ?

and there already has test name as "archive-big-print.test " in the patch.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

59

please add ; after the definition of class of above code

[jhenderson]

llvm/include/llvm/Object/Archive.h

35–39

No need to change this at this point, but noting that a later patch to rename Archive to UnixArchive or similar, should probably result in renaming ArchiveMagic to UnixArchiveMagic.

59

Fair point about the compilation issue. Maybe we should just move the A classes out of their parent classes? I'm not sure the nesting really gives us that much, and it seems to be making things more complex. What do you think?

76

I'm not sure what code you're referencing here, but it's irrelevant. virtual is "inherited" from overridden functions. This isThin function is declared to be virtual in a base class (as shown by the use of override. That means all subclass isThin functions will be virtual automatically, and don't need to be annotated as such. The use of override makes it clear that this function MUST be virtual, so the old pre-C++11 practice of marking subclass functions as virtual to indicate they are overriding base class functions is no longer necessary.

(If you think you need virtual for isThin, why don't you need it for e.g. getName, getSize etc?)

382

Ping? Linter is still complaining about lack of clang-formatting here.

llvm/lib/Object/Archive.cpp

191

evenAlign might be a little clearer as to the intent.

454–456

That being said, there are some functions elsewhere within LLVM that align things (see "alignTo"). Could you use that instead. here and in similar places?

Thanks for the helper, but did you look for other LLVM functions?

1200

Already highlighted before with my above comment with "and below": "aix" -> "AIX"

llvm/test/Object/archive-big-extract.test

5

If empty.o is just an empty file, rather than an object file, don't use it here in the diff. Instead, use touch or echo to create a new file with contents that exactly match those that are expected, and diff using that instead. This will remove one dependency on a canned object.

llvm/test/Object/archive-big-print.test

3

You're still unnecessarily using --check-prefix. Please fix here and in every other test you're adding.

llvm/test/Object/archive-big-read.test

1

This STILL hasn't been addressed, despite being marked as done. Please fix.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

35–39

since Archive.h is included in the files of llvm tools. "Magic" is a common name. if the source code of llvm tools define global "Magic", it will be a conflict. I think it is better to change from "Magic" to "ArchiveMagic" now. , and change to UnixArchiveMagic in later patch.

59

yes, I think it seems making thing more complex.

what you concern about

That'll avoid the need for a) the friend declarations (I believe), and b) the need to repeatedly do const T &DerivedMemberHeader = static_cast<const T &>(*this); in the get* methods.

a), I can change the

private:
  struct ArMemHdrType {
  }

to public to avoid te friend. But I am prefer keeping the private for "struct ArMemHdrType"

b) I have added a helper function

const T &getDerivedMemberHeader() const

to avoid "repeatedly do const T &DerivedMemberHeader = static_cast<const T &>(*this); in the get* methods ".

76

sorry for misunderstand your comment.

llvm/lib/Object/Archive.cpp

191

thanks

llvm/test/Object/archive-big-extract.test

5

we do not need to test a real xcoff object. We can test extracting any file from archive.

[jhenderson]

llvm/include/llvm/Object/Archive.h

35–39

I think that's what I said to do? (i.e. as-is, this bit of the patch is fine, just remember to rename the Magic variable in a later patch)

59

I'm not sure the nesting really gives us that much, and it seems to be making things more complex

I think you've misunderstood this. When I said it seems to be making things more complex, I mean that the current state of the code in this patch is making things more complex. By having the structs as private nested members, we are forced to use friend and have that helper method with the static_cast. This is more complex than not having those things. Making the classes independent would avoid the need for these bits, I believe, reducing complexity. The only cost is that other functions and classes have direct access to these classes, but I'm not sure how that's a real problem.

llvm/lib/Object/Archive.cpp

202

Please remember to clang-format before posting patches up for review.

llvm/test/Object/archive-big-extract.test

6

cmp tends to be more common than diff in tests I've seen doing similar things.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

35–39

thanks.

59

I think put the definition
struct ArMemHdrType {

}

in the struct
ArchiveMemberHeader {
}
is more clear to show that the ArMemHdrType is one part of ArchiveMemberHeader.
and a small helper function is not a big problem.

anyway, I changed as your suggestion.

llvm/test/Object/archive-big-extract.test

6

thanks

[jhenderson]

I think we're basically there. Just some nits to sort out.

llvm/include/llvm/Object/Archive.h

69

Please delete blank lines at starts of classes/functions/blocks etc.

71

Please remember to clang-format each diff.

llvm/lib/Object/Archive.cpp

196

I'd delete this blank line, so that the setting of the actual name length is tied to the bit before.

199

201

I'd probably delete this blank line.

206

Ditto.

Deleting these two blank lines helps tie together the padding/terminator logic with the associated comment.

383

Still not clang-formatted...

399–401

No braces for single line ifs.

456

Still not clang-formatted...

725–729

747

Delete this blank line.

1192

I'd delete this blank line, so that RawOffset is tied to the bit it's used in.

1198

Ditto.

1216

This undef is now unnecessary.

[DiggerLin]

llvm/lib/Object/Archive.cpp

1216

thanks

[jhenderson]

Apologies, missed one signficant thing in my previous review: change createArchiveMemberHeader to make and return a unique_ptr

llvm/include/llvm/Object/Archive.h

361

llvm/lib/Object/Archive.cpp

459–460

Related to other comment.

476–481

Related to other comment.

721–728

Use std::unique_ptr/std::make_unique rather than new and raw pointers here.

Also, no need for else after return.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

361

thanks.

[jhenderson]

I'm giving this an LGTM on the basis that the "normal" functionality looks good, and it's not worth blocking it further, awaiting yaml2obj support. However, before you commit this, I'd like you to add the following comment to all the places I've highlighted with this batch of inline comments: TODO: Add testing, as there are numerous parts that are untested, primarily to do with invalid/malformed archives.

llvm/lib/Object/Archive.cpp

195

Add TODO, as noted out-of-line.

208

Add TODO, as noted out-of-line.

472

Let's readd this comment.

476

Let's readd this comment (sorry if I asked for it to be removed earlier...)

1193

Add TODO, as noted out-of-line.

1198

Add TODO, as noted out-of-line.

llvm/test/tools/llvm-objdump/malformed-archives.test

180 ↗

(On Diff #399681)

Add ## TODO: add testing for AIX Big archive to the end of this file (with a blank line between it and the previous line).

[DiggerLin]

llvm/lib/Object/Archive.cpp

476

the code

std::string Msg("offset to next archive member past the end of the archive  after member ");

explain it.

but I added it anyway.

[ronlieb]

seeing a buildbot failure on ;: https://lab.llvm.org/buildbot/#/builders/193/builds/4748

[fhahn]

This appears to be causing the following build failures on green dragon during stage2 builds on macOS (https://green.lab.llvm.org/green/job/clang-stage2-Rthinlto/5188/):

 && /Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/host-compiler/bin/clang++  -fno-stack-protector -fno-common -Wno-profile-instr-unprofiled -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -fmodules -fmodules-cache-path=/Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/module.cache -fcxx-modules -Xclang -fmodules-local-submodule-visibility -gmodules -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -fdiagnostics-color -flto=thin -O2 -g -DNDEBUG -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk -Wl,-search_paths_first -Wl,-headerpad_max_install_names -flto=thin -Wl,-cache_path_lto,/Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/lto.cache    -Wl,-dead_strip -Wl,-object_path_lto,/Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/tools/llvm-ar/./llvm-ar-lto.o tools/llvm-ar/CMakeFiles/llvm-ar.dir/llvm-ar.cpp.o  -o bin/llvm-ar  -Wl,-rpath,@loader_path/../lib  lib/libLLVMX86AsmParser.a  lib/libLLVMARMAsmParser.a  lib/libLLVMAArch64AsmParser.a  lib/libLLVMX86Desc.a  lib/libLLVMARMDesc.a  lib/libLLVMAArch64Desc.a  lib/libLLVMX86Info.a  lib/libLLVMARMInfo.a  lib/libLLVMAArch64Info.a  lib/libLLVMBinaryFormat.a  lib/libLLVMCore.a  lib/libLLVMDlltoolDriver.a  lib/libLLVMLibDriver.a  lib/libLLVMObject.a  lib/libLLVMSupport.a  lib/libLLVMMCDisassembler.a  lib/libLLVMARMUtils.a  lib/libLLVMAArch64Utils.a  lib/libLLVMMCParser.a  lib/libLLVMMC.a  lib/libLLVMDebugInfoCodeView.a  lib/libLLVMTextAPI.a  lib/libLLVMOption.a  lib/libLLVMBitReader.a  lib/libLLVMCore.a  lib/libLLVMBinaryFormat.a  lib/libLLVMRemarks.a  lib/libLLVMBitstreamReader.a  lib/libLLVMSupport.a  -lm  /usr/lib/libz.dylib  /usr/lib/libcurses.dylib  lib/libLLVMDemangle.a && cd /Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/tools/llvm-ar && /Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/host-compiler/bin/dsymutil -o=llvm-ar.dSYM /Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/bin/llvm-ar && /usr/bin/strip -S -x /Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/bin/llvm-ar
Undefined symbols for architecture x86_64:
  "llvm::object::CommonArchiveMemberHeader<llvm::object::BigArMemHdrType>::getRawAccessMode() const", referenced from:
      vtable for llvm::object::BigArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::BigArMemHdrType>::getRawUID() const", referenced from:
      vtable for llvm::object::BigArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::BigArMemHdrType>::getRawGID() const", referenced from:
      vtable for llvm::object::BigArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::UnixArMemHdrType>::getRawAccessMode() const", referenced from:
      vtable for llvm::object::ArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::UnixArMemHdrType>::getRawLastModified() const", referenced from:
      vtable for llvm::object::ArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::BigArMemHdrType>::getRawLastModified() const", referenced from:
      vtable for llvm::object::BigArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::BigArMemHdrType>::getOffset() const", referenced from:
      vtable for llvm::object::BigArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::UnixArMemHdrType>::getRawUID() const", referenced from:
      vtable for llvm::object::ArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::UnixArMemHdrType>::getRawGID() const", referenced from:
      vtable for llvm::object::ArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::UnixArMemHdrType>::getOffset() const", referenced from:
      vtable for llvm::object::ArchiveMemberHeader in 107.x86_64.thinlto.o
ld: symbol(s) not found for architecture x86_64

I reverted the commit for now to get the bots back to green.

[DiggerLin]

In D111889#3250958, @fhahn wrote:

This appears to be causing the following build failures on green dragon during stage2 builds on macOS (https://green.lab.llvm.org/green/job/clang-stage2-Rthinlto/5188/):

 && /Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/host-compiler/bin/clang++  -fno-stack-protector -fno-common -Wno-profile-instr-unprofiled -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -fmodules -fmodules-cache-path=/Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/module.cache -fcxx-modules -Xclang -fmodules-local-submodule-visibility -gmodules -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -fdiagnostics-color -flto=thin -O2 -g -DNDEBUG -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk -Wl,-search_paths_first -Wl,-headerpad_max_install_names -flto=thin -Wl,-cache_path_lto,/Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/lto.cache    -Wl,-dead_strip -Wl,-object_path_lto,/Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/tools/llvm-ar/./llvm-ar-lto.o tools/llvm-ar/CMakeFiles/llvm-ar.dir/llvm-ar.cpp.o  -o bin/llvm-ar  -Wl,-rpath,@loader_path/../lib  lib/libLLVMX86AsmParser.a  lib/libLLVMARMAsmParser.a  lib/libLLVMAArch64AsmParser.a  lib/libLLVMX86Desc.a  lib/libLLVMARMDesc.a  lib/libLLVMAArch64Desc.a  lib/libLLVMX86Info.a  lib/libLLVMARMInfo.a  lib/libLLVMAArch64Info.a  lib/libLLVMBinaryFormat.a  lib/libLLVMCore.a  lib/libLLVMDlltoolDriver.a  lib/libLLVMLibDriver.a  lib/libLLVMObject.a  lib/libLLVMSupport.a  lib/libLLVMMCDisassembler.a  lib/libLLVMARMUtils.a  lib/libLLVMAArch64Utils.a  lib/libLLVMMCParser.a  lib/libLLVMMC.a  lib/libLLVMDebugInfoCodeView.a  lib/libLLVMTextAPI.a  lib/libLLVMOption.a  lib/libLLVMBitReader.a  lib/libLLVMCore.a  lib/libLLVMBinaryFormat.a  lib/libLLVMRemarks.a  lib/libLLVMBitstreamReader.a  lib/libLLVMSupport.a  -lm  /usr/lib/libz.dylib  /usr/lib/libcurses.dylib  lib/libLLVMDemangle.a && cd /Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/tools/llvm-ar && /Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/host-compiler/bin/dsymutil -o=llvm-ar.dSYM /Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/bin/llvm-ar && /usr/bin/strip -S -x /Users/buildslave/jenkins/workspace/clang-stage2-Rthinlto/clang-build/Build/bin/llvm-ar
Undefined symbols for architecture x86_64:
  "llvm::object::CommonArchiveMemberHeader<llvm::object::BigArMemHdrType>::getRawAccessMode() const", referenced from:
      vtable for llvm::object::BigArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::BigArMemHdrType>::getRawUID() const", referenced from:
      vtable for llvm::object::BigArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::BigArMemHdrType>::getRawGID() const", referenced from:
      vtable for llvm::object::BigArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::UnixArMemHdrType>::getRawAccessMode() const", referenced from:
      vtable for llvm::object::ArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::UnixArMemHdrType>::getRawLastModified() const", referenced from:
      vtable for llvm::object::ArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::BigArMemHdrType>::getRawLastModified() const", referenced from:
      vtable for llvm::object::BigArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::BigArMemHdrType>::getOffset() const", referenced from:
      vtable for llvm::object::BigArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::UnixArMemHdrType>::getRawUID() const", referenced from:
      vtable for llvm::object::ArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::UnixArMemHdrType>::getRawGID() const", referenced from:
      vtable for llvm::object::ArchiveMemberHeader in 107.x86_64.thinlto.o
  "llvm::object::CommonArchiveMemberHeader<llvm::object::UnixArMemHdrType>::getOffset() const", referenced from:
      vtable for llvm::object::ArchiveMemberHeader in 107.x86_64.thinlto.o
ld: symbol(s) not found for architecture x86_64

I reverted the commit for now to get the bots back to green.

we should Explicit Instantiate

template class object::CommonArchiveMemberHeader<UnixArMemHdrType>;
template class object::CommonArchiveMemberHeader<BigArMemHdrType>;

[DiggerLin]

In D111889#3248664, @ronlieb wrote:

seeing a buildbot failure on ;: https://lab.llvm.org/buildbot/#/builders/193/builds/4748

we should use return std::move(Ret) instead of return Ret.

llvm/include/llvm/Object/Archive.h

 #include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace llvm {
 namespace object {
 
 class Archive;
 
-class ArchiveMemberHeader {
+class AbstractArchiveMemberHeader {
 public:
   friend class Archive;
-
-  ArchiveMemberHeader(Archive const *Parent, const char *RawHeaderPtr,
-                      uint64_t Size, Error *Err);
-  // ArchiveMemberHeader() = default;
-
+  virtual std::unique_ptr<AbstractArchiveMemberHeader> clone() const = 0;
+  virtual ~AbstractArchiveMemberHeader(){};
   /// Get the name without looking up long names.
-  Expected<StringRef> getRawName() const;
+  virtual Expected<StringRef> getRawName() const = 0;
 
   /// Get the name looking up long names.
-  Expected<StringRef> getName(uint64_t Size) const;
+  virtual Expected<StringRef> getName(uint64_t Size) const = 0;
 
-  Expected<uint64_t> getSize() const;
+  virtual Expected<uint64_t> getSize() const = 0;
+  virtual uint64_t getOffset() const = 0;
+
+  virtual StringRef getRawAccessMode() const = 0;
+  virtual StringRef getRawLastModified() const = 0;
+  virtual StringRef getRawUID() const = 0;
+  virtual StringRef getRawGID() const = 0;
 
   Expected<sys::fs::perms> getAccessMode() const;
   Expected<sys::TimePoint<std::chrono::seconds>> getLastModified() const;
 
-  StringRef getRawLastModified() const {
-    return StringRef(ArMemHdr->LastModified, sizeof(ArMemHdr->LastModified))
-        .rtrim(' ');
-  }
-
   Expected<unsigned> getUID() const;
   Expected<unsigned> getGID() const;
 
-  // This returns the size of the private struct ArMemHdrType
-  uint64_t getSizeOf() const { return sizeof(ArMemHdrType); }
+  // Returns the size in bytes of the format-defined header of derived class.
+  virtual uint64_t getSizeOf() const { return 0; }
+
+  Archive const *Parent;
+  AbstractArchiveMemberHeader(const Archive *Parent) : Parent(Parent){};
+};
+
+class ArchiveMemberHeader : public AbstractArchiveMemberHeader {
+public:
+  ArchiveMemberHeader(const Archive *Parent, const char *RawHeaderPtr,
+                      uint64_t Size, Error *Err);
+
+  std::unique_ptr<AbstractArchiveMemberHeader> clone() const override {
+    return std::unique_ptr<AbstractArchiveMemberHeader>(
+        new ArchiveMemberHeader(*this));
+  }
+
+  Expected<StringRef> getRawName() const override;
+  Expected<StringRef> getName(uint64_t Size) const override;
+  Expected<uint64_t> getSize() const override;
+
+  uint64_t getOffset() const override;
+  StringRef getRawAccessMode() const override;
+  StringRef getRawLastModified() const override;
+  StringRef getRawUID() const override;
+  StringRef getRawGID() const override;
+
+  uint64_t getSizeOf() const override { return sizeof(ArMemHdrType); }
 
 private:
   struct ArMemHdrType {
     char Name[16];
     char LastModified[12];
     char UID[6];
     char GID[6];
     char AccessMode[8];
     char Size[10]; ///< Size of data, not including header or padding.
     char Terminator[2];
   };
-  Archive const *Parent;
+  ArMemHdrType const *ArMemHdr;
+};
+
+class BigArchiveMemberHeader : public AbstractArchiveMemberHeader {
+public:
+  BigArchiveMemberHeader(Archive const *Parent, const char *RawHeaderPtr,
+                         uint64_t Size, Error *Err);
+  std::unique_ptr<AbstractArchiveMemberHeader> clone() const override {
+    return std::unique_ptr<AbstractArchiveMemberHeader>(
+        new BigArchiveMemberHeader(*this));
+  }
+
+  Expected<StringRef> getRawName() const override;
+  Expected<StringRef> getName(uint64_t Size) const override;
+  Expected<uint64_t> getSize() const override;
+
+  uint64_t getOffset() const override;
+  StringRef getRawAccessMode() const override;
+  StringRef getRawLastModified() const override;
+  StringRef getRawUID() const override;
+  StringRef getRawGID() const override;
+
+  uint64_t getSizeOf() const override { return sizeof(ArMemHdrType); }
+  Expected<uint64_t> getNextOffset() const;
+  static bool classof(AbstractArchiveMemberHeader const *Header);
+
+private:
+  // File Member Header
+  struct ArMemHdrType {
+    char Size[20];       // File member size in decimal
+    char NextOffset[20]; // Next member offset in decimal
+    char PrevOffset[20]; // Previous member offset in decimal
+    char LastModified[12];
+    char UID[12];
+    char GID[12];
+    char AccessMode[12];
+    char NameLen[4]; // File member name length in decimal
+    union {
+      char Name[2]; // Start of member name
+      char Terminator[2];
+    };
+  };
+
   ArMemHdrType const *ArMemHdr;
 };
 
 class Archive : public Binary {
   virtual void anchor();
 
 public:
   class Child {
     friend Archive;
-    friend ArchiveMemberHeader;
+    friend AbstractArchiveMemberHeader;
 
     const Archive *Parent;
-    ArchiveMemberHeader Header;
+    std::unique_ptr<AbstractArchiveMemberHeader> Header;
     /// Includes header but not padding byte.
     StringRef Data;
     /// Offset from Data to the start of the file.
     uint16_t StartOfFile;
 
     Expected<bool> isThinMember() const;
 
   public:
     Child(const Archive *Parent, const char *Start, Error *Err);
     Child(const Archive *Parent, StringRef Data, uint16_t StartOfFile);
 
+    Child(const Child &C)
+       : Parent(C.Parent), Data(C.Data), StartOfFile(C.StartOfFile) {
+      if (C.Header)
+        Header = C.Header->clone();
+    }
+
+    Child(Child &&C) {
+      Parent = std::move(C.Parent);
+      Header = std::move(C.Header);
+      Data = C.Data;
+      StartOfFile = C.StartOfFile;
+    }
+
+    Child &operator=(Child &&C) noexcept {
+      if (&C == this)
+        return *this;
+
+      Parent = std::move(C.Parent);
+      Header = std::move(C.Header);
+      Data = C.Data;
+      StartOfFile = C.StartOfFile;
+
+      return *this;
+    }
+
+    Child &operator=(const Child &C) {
+      if (&C == this)
+        return *this;
+
+      Parent = C.Parent;
+      if (C.Header)
+        Header = C.Header->clone();
+      Data = C.Data;
+      StartOfFile = C.StartOfFile;
+
+      return *this;
+    }
+
     bool operator==(const Child &other) const {
       assert(!Parent || !other.Parent || Parent == other.Parent);
       return Data.begin() == other.Data.begin();
     }
 
     const Archive *getParent() const { return Parent; }
     Expected<Child> getNext() const;
 
     Expected<StringRef> getName() const;
     Expected<std::string> getFullName() const;
-    Expected<StringRef> getRawName() const { return Header.getRawName(); }
+    Expected<StringRef> getRawName() const { return Header->getRawName(); }
 
     Expected<sys::TimePoint<std::chrono::seconds>> getLastModified() const {
-      return Header.getLastModified();
+      return Header->getLastModified();
     }
 
-    StringRef getRawLastModified() const { return Header.getRawLastModified(); }
+    StringRef getRawLastModified() const {
+      return Header->getRawLastModified();
+    }
 
-    Expected<unsigned> getUID() const { return Header.getUID(); }
-    Expected<unsigned> getGID() const { return Header.getGID(); }
+    Expected<unsigned> getUID() const { return Header->getUID(); }
+    Expected<unsigned> getGID() const { return Header->getGID(); }
 
     Expected<sys::fs::perms> getAccessMode() const {
-      return Header.getAccessMode();
+      return Header->getAccessMode();
     }
 
     /// \return the size of the archive member without the header or padding.
     Expected<uint64_t> getSize() const;
     /// \return the size in the archive header for this member.
     Expected<uint64_t> getRawSize() const;
 
     Expected<StringRef> getBuffer() const;
public:
   };
 
   Archive(MemoryBufferRef Source, Error &Err);
   static Expected<std::unique_ptr<Archive>> create(MemoryBufferRef Source);
 
   /// Size field is 10 decimal digits long
   static const uint64_t MaxMemberSize = 9999999999;
 
-  enum Kind { K_GNU, K_GNU64, K_BSD, K_DARWIN, K_DARWIN64, K_COFF };
+  enum Kind { K_GNU, K_GNU64, K_BSD, K_DARWIN, K_DARWIN64, K_COFF, K_AIXBIG };
 
   Kind kind() const { return (Kind)Format; }
   bool isThin() const { return IsThin; }
 
   child_iterator child_begin(Error &Err, bool SkipInternal = true) const;
   child_iterator child_end() const;
   iterator_range<child_iterator> children(Error &Err,
                                           bool SkipInternal = true) const {
     return make_range(child_begin(Err, SkipInternal), child_end());
   }
 
   symbol_iterator symbol_begin() const;
   symbol_iterator symbol_end() const;
   iterator_range<symbol_iterator> symbols() const {
     return make_range(symbol_begin(), symbol_end());
   }
 
-  // Cast methods.
   static bool classof(Binary const *v) { return v->isArchive(); }
 
   // check if a symbol is in the archive
   Expected<Optional<Child>> findSym(StringRef name) const;
 
   bool isEmpty() const;
   bool hasSymbolTable() const;
   StringRef getSymbolTable() const { return SymbolTable; }
   StringRef getStringTable() const { return StringTable; }
   uint32_t getNumberOfSymbols() const;
+  virtual uint64_t getFirstChildOffset() const { return ArchiveMagicLen; }
 
   std::vector<std::unique_ptr<MemoryBuffer>> takeThinBuffers() {
     return std::move(ThinBuffers);
   }
 
+protected:
+  static constexpr int ArchiveMagicLen = 8;
+  void setFirstRegular(const Child &C);
+
 private:
   StringRef SymbolTable;
   StringRef StringTable;
 
   StringRef FirstRegularData;
   uint16_t FirstRegularStartOfFile = -1;
-  void setFirstRegular(const Child &C);
 
   unsigned Format : 3;
   unsigned IsThin : 1;
   mutable std::vector<std::unique_ptr<MemoryBuffer>> ThinBuffers;
 };
 
+class BigArchive : public Archive {
+  /// Fixed-Length Header.
+  struct BigArFixLenHdrType {
+    char Magic[ArchiveMagicLen]; ///< Big archive magic string.
+    char MemOffset[20];          ///< Offset to member table.
+    char GlobSymOffset[20];      ///< Offset to global symbol table.
+    char
+        GlobSym64Offset[20]; ///< Offset global symbol table for 64-bit objects.
+    char FirstMemberOffset[20]; ///< Offset to first archive member.
+    char LastMemberOffset[20];  ///< Offset to last archive member.
+    char FreeOffset[20];     ///< Offset to first mem on free list.
+  };
+
+  const BigArFixLenHdrType *ArFixLenHdr;
+  uint64_t FirstMemberOffset = 0;
+  uint64_t LastMemberOffset = 0;
+
+public:
+  BigArchive(MemoryBufferRef Source, Error &Err);
+  uint64_t getFirstChildOffset() const override { return FirstMemberOffset; }
+  uint64_t getLastChildOffset() const { return LastMemberOffset; }
+};
+
 } // end namespace object
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_ARCHIVE_H

llvm/lib/BinaryFormat/Magic.cpp

file_magic llvm::identify_magic(StringRef Magic) {
   case 'B':
     if (startswith(Magic, "BC\xC0\xDE"))
       return file_magic::bitcode;
     break;
   case '!':
     if (startswith(Magic, "!<arch>\n") || startswith(Magic, "!<thin>\n"))
       return file_magic::archive;
     break;
+  case '<':
+    if (startswith(Magic, "<bigaf>\n"))
+      return file_magic::archive;
+    break;
+
   case '\177':
     if (startswith(Magic, "\177ELF") && Magic.size() >= 18) {
       bool Data2MSB = Magic[5] == 2;
       unsigned high = Data2MSB ? 16 : 17;
       unsigned low = Data2MSB ? 17 : 16;
       if (Magic[high] == 0) {
         switch (Magic[low]) {
         default:

llvm/lib/Object/Archive.cpp

 
 #include "llvm/Object/Archive.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Error.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <memory>
+#include <stddef.h>
 #include <string>
 #include <system_error>
 
 using namespace llvm;
 using namespace object;
 using namespace llvm::support::endian;
 
 const char Magic[] = "!<arch>\n";
 const char ThinMagic[] = "!<thin>\n";
+const char BigMagic[] = "<bigaf>\n";
 
 void Archive::anchor() {}
 
 static Error malformedError(Twine Msg) {
   std::string StringMsg = "truncated or malformed archive (" + Msg.str() + ")";
   return make_error<GenericBinaryError>(std::move(StringMsg),
                                         object_error::parse_failed);
 }
 
 ArchiveMemberHeader::ArchiveMemberHeader(const Archive *Parent,
                                          const char *RawHeaderPtr,
                                          uint64_t Size, Error *Err)
-    : Parent(Parent),
-      ArMemHdr(reinterpret_cast<const ArMemHdrType *>(RawHeaderPtr)) {
+    : AbstractArchiveMemberHeader(Parent) {
   if (RawHeaderPtr == nullptr)
     return;
   ErrorAsOutParameter ErrAsOutParam(Err);
 
+  ArMemHdr = reinterpret_cast<const ArMemHdrType *>(RawHeaderPtr);
+
   if (Size < sizeof(ArMemHdrType)) {
     if (Err) {
       std::string Msg("remaining size of archive too small for next archive "
                       "member header ");
       Expected<StringRef> NameOrErr = getName(Size);
       if (!NameOrErr) {
         consumeError(NameOrErr.takeError());
         uint64_t Offset = RawHeaderPtr - Parent->getData().data();
         *Err = malformedError(Msg + "at offset " + Twine(Offset));
       } else
         *Err = malformedError(Msg + "for " + NameOrErr.get());
     }
     return;
   }
   if (ArMemHdr->Terminator[0] != '`' || ArMemHdr->Terminator[1] != '\n') {
     if (Err) {
       std::string Buf;
       raw_string_ostream OS(Buf);
       OS.write_escaped(
           StringRef(ArMemHdr->Terminator, sizeof(ArMemHdr->Terminator)));
       OS.flush();
       std::string Msg("terminator characters in archive member \"" + Buf +
                       "\" not the correct \"`\\n\" values for the archive "
                       "member header ");
       Expected<StringRef> NameOrErr = getName(Size);
       if (!NameOrErr) {
         consumeError(NameOrErr.takeError());
         uint64_t Offset = RawHeaderPtr - Parent->getData().data();
         *Err = malformedError(Msg + "at offset " + Twine(Offset));
       } else
         *Err = malformedError(Msg + "for " + NameOrErr.get());
     }
     return;
   }
 }
 
+BigArchiveMemberHeader::BigArchiveMemberHeader(const Archive *Parent,
+                                               const char *RawHeaderPtr,
+                                               uint64_t Size, Error *Err)
+    : AbstractArchiveMemberHeader(Parent) {
+  if (RawHeaderPtr == nullptr)
+    return;
+  ErrorAsOutParameter ErrAsOutParam(Err);
+
+  ArMemHdr = reinterpret_cast<const ArMemHdrType *>(RawHeaderPtr);
+
+  if (Size < sizeof(ArMemHdrType)) {
+    if (Err) {
+      std::string Msg("remaining size of archive too small for next archive "
+                      "member header ");
+      Expected<StringRef> NameOrErr = getName(Size);
+      if (!NameOrErr) {
+        consumeError(NameOrErr.takeError());
+        uint64_t Offset = RawHeaderPtr - Parent->getData().data();
+        *Err = malformedError(Msg + "at offset " + Twine(Offset));
+      } else
+        *Err = malformedError(Msg + "for " + NameOrErr.get());
+    }
+    return;
+  }
+
+}
+
 // This gets the raw name from the ArMemHdr->Name field and checks that it is
 // valid for the kind of archive.  If it is not valid it returns an Error.
 Expected<StringRef> ArchiveMemberHeader::getRawName() const {
   char EndCond;
   auto Kind = Parent->kind();
   if (Kind == Archive::K_BSD || Kind == Archive::K_DARWIN64) {
     if (ArMemHdr->Name[0] == ' ') {
       uint64_t Offset =
StringRef::size_type end =
       StringRef(ArMemHdr->Name, sizeof(ArMemHdr->Name)).find(EndCond);
   if (end == StringRef::npos)
     end = sizeof(ArMemHdr->Name);
   assert(end <= sizeof(ArMemHdr->Name) && end > 0);
   // Don't include the EndCond if there is one.
   return StringRef(ArMemHdr->Name, end);
 }
 
-// This gets the name looking up long names. Size is the size of the archive
+bool BigArchiveMemberHeader::classof(
+    const AbstractArchiveMemberHeader *Header) {
+  return Header->Parent->kind() == Archive::K_AIXBIG;
+}
+
+Expected<StringRef> BigArchiveMemberHeader::getRawName() const {
+  StringRef::size_type NameSize = strtol(ArMemHdr->NameLen, NULL, 10);
+  return StringRef(ArMemHdr->Name, NameSize);
+}
+
 // member including the header, so the size of any name following the header
 // is checked to make sure it does not overflow.
 Expected<StringRef> ArchiveMemberHeader::getName(uint64_t Size) const {
 
   // This can be called from the ArchiveMemberHeader constructor when the
   // archive header is truncated to produce an error message with the name.
   // Make sure the name field is not truncated.
   if (Size < offsetof(ArMemHdrType, Name) + sizeof(ArMemHdr->Name)) {
if (!NameOrErr)
     return NameOrErr.takeError();
   StringRef Name = NameOrErr.get();
 
   // Check if it's a special name.
   if (Name[0] == '/') {
     if (Name.size() == 1) // Linker member.
       return Name;
     if (Name.size() == 2 && Name[1] == '/') // String table.
       return Name;
     // It's a long name.
     // Get the string table offset.
     std::size_t StringOffset;
     if (Name.substr(1).rtrim(' ').getAsInteger(10, StringOffset)) {
       std::string Buf;
       raw_string_ostream OS(Buf);
       OS.write_escaped(Name.substr(1).rtrim(' '));
       OS.flush();
       uint64_t ArchiveOffset =
           reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
       return malformedError("long name offset characters after the '/' are "
                             "not all decimal numbers: '" +
                             Buf + "' for archive member header at offset " +
                             Twine(ArchiveOffset));
     }
 
     // Verify it.
     if (StringOffset >= Parent->getStringTable().size()) {
       uint64_t ArchiveOffset =
           reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
       return malformedError("long name offset " + Twine(StringOffset) +
                             " past the end of the string table for archive "
                             "member header at offset " +
                             Twine(ArchiveOffset));
     }
 
     // GNU long file names end with a "/\n".
     if (Parent->kind() == Archive::K_GNU ||
         Parent->kind() == Archive::K_GNU64) {
Expected<StringRef> ArchiveMemberHeader::getName(uint64_t Size) const {
   // It is not a long name so trim the blanks at the end of the name.
   if (Name[Name.size() - 1] != '/')
     return Name.rtrim(' ');
 
   // It's a simple name.
   return Name.drop_back(1);
 }
 
+Expected<StringRef> BigArchiveMemberHeader::getName(uint64_t Size) const {
+  // The raw name itself can be invalid.
+  Expected<StringRef> NameOrErr = getRawName();
+  if (!NameOrErr)
+    return NameOrErr.takeError();
+  return NameOrErr.get();
+}
+
 Expected<uint64_t> ArchiveMemberHeader::getSize() const {
-  uint64_t Ret;
-  if (StringRef(ArMemHdr->Size, sizeof(ArMemHdr->Size))
-          .rtrim(" ")
-          .getAsInteger(10, Ret)) {
-    std::string Buf;
-    raw_string_ostream OS(Buf);
-    OS.write_escaped(
-        StringRef(ArMemHdr->Size, sizeof(ArMemHdr->Size)).rtrim(" "));
-    OS.flush();
+  uint64_t Size;
+  StringRef RawSize =
+      StringRef(ArMemHdr->Size, sizeof(ArMemHdr->Size)).rtrim(" ");
+  if (RawSize.getAsInteger(10, Size)) {
     uint64_t Offset =
         reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
     return malformedError("characters in size field in archive header are not "
                           "all decimal numbers: '" +
-                          Buf +
+                          RawSize +
                           "' for archive "
                           "member header at offset " +
                           Twine(Offset));
   }
-  return Ret;
+  return Size;
 }
 
-Expected<sys::fs::perms> ArchiveMemberHeader::getAccessMode() const {
-  unsigned Ret;
-  if (StringRef(ArMemHdr->AccessMode, sizeof(ArMemHdr->AccessMode))
-          .rtrim(' ')
-          .getAsInteger(8, Ret)) {
-    std::string Buf;
-    raw_string_ostream OS(Buf);
-    OS.write_escaped(
-        StringRef(ArMemHdr->AccessMode, sizeof(ArMemHdr->AccessMode))
-            .rtrim(" "));
-    OS.flush();
+Expected<uint64_t> BigArchiveMemberHeader::getSize() const {
+  uint64_t Size;
+  uint64_t NameLen;
+  StringRef RawSize =
+      StringRef(ArMemHdr->Size, sizeof(ArMemHdr->Size)).rtrim(" ");
+  if (RawSize.getAsInteger(10, Size)) {
     uint64_t Offset =
         reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
+    return malformedError("characters in size field in archive header are not "
+                          "all decimal numbers: '" +
+                          RawSize +
+                          "' for archive "
+                          "member header at offset " +
+                          Twine(Offset));
+  }
+
+  StringRef RawNameLen =
+      StringRef(ArMemHdr->NameLen, sizeof(ArMemHdr->NameLen)).rtrim(" ");
+  if (RawNameLen.getAsInteger(10, NameLen)) {
+    uint64_t Offset =
+        reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
+    return malformedError(
+        "characters in name length field in archive header are not "
+        "all decimal numbers: '" +
+        RawNameLen +
+        "' for archive "
+        "member header at offset " +
+        Twine(Offset));
+  }
+  return Size + (((NameLen + 1) >> 1) << 1);
+}
+
+Expected<uint64_t> BigArchiveMemberHeader::getNextOffset() const {
+  uint64_t NextOffset;
+  StringRef RawStringRef =
+      StringRef(ArMemHdr->NextOffset, sizeof(ArMemHdr->NextOffset)).rtrim(" ");
+
+  if (RawStringRef.getAsInteger(10, NextOffset)) {
+    uint64_t Offset = reinterpret_cast<const char *>(ArMemHdr->NextOffset) -
+                      Parent->getData().data();
+    return malformedError("characters in size field in archive header are not "
+                          "all decimal numbers: '" +
+                          RawStringRef +
+                          "' for archive "
+                          "member header at offset " +
+                          Twine(Offset));
+  }
+  return NextOffset;
+}
+
+uint64_t ArchiveMemberHeader::getOffset() const {
+  uint64_t Offset =
+      reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
+  return Offset;
+}
+
+uint64_t BigArchiveMemberHeader::getOffset() const {
+  uint64_t Offset =
+      reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
+  return Offset;
+}
+
+// This gets the raw access mode from the ArMemHdr->AccessMode field.
+StringRef ArchiveMemberHeader::getRawAccessMode() const {
+  return StringRef(ArMemHdr->AccessMode, sizeof(ArMemHdr->AccessMode))
+      .rtrim(' ');
+}
+
+StringRef BigArchiveMemberHeader::getRawAccessMode() const {
+  return StringRef(ArMemHdr->AccessMode, sizeof(ArMemHdr->AccessMode))
+      .rtrim(' ');
+}
+
+Expected<sys::fs::perms> AbstractArchiveMemberHeader::getAccessMode() const {
+  unsigned Ret;
+  if (getRawAccessMode().getAsInteger(8, Ret)) {
+    uint64_t Offset = getOffset();
     return malformedError("characters in AccessMode field in archive header "
                           "are not all decimal numbers: '" +
-                          Buf + "' for the archive member header at offset " +
+                          getRawAccessMode() +
+                          "' for the archive member header at offset " +
                           Twine(Offset));
   }
   return static_cast<sys::fs::perms>(Ret);
 }
 
+// This gets ArMemHdr->LastModified field.
+StringRef ArchiveMemberHeader::getRawLastModified() const {
+  return StringRef(ArMemHdr->LastModified, sizeof(ArMemHdr->LastModified))
+      .rtrim(' ');
+}
+
+StringRef BigArchiveMemberHeader::getRawLastModified() const {
+  return StringRef(ArMemHdr->LastModified, sizeof(ArMemHdr->LastModified))
+      .rtrim(' ');
+}
+
 Expected<sys::TimePoint<std::chrono::seconds>>
-ArchiveMemberHeader::getLastModified() const {
+AbstractArchiveMemberHeader::getLastModified() const {
   unsigned Seconds;
-  if (StringRef(ArMemHdr->LastModified, sizeof(ArMemHdr->LastModified))
-          .rtrim(' ')
-          .getAsInteger(10, Seconds)) {
-    std::string Buf;
-    raw_string_ostream OS(Buf);
-    OS.write_escaped(
-        StringRef(ArMemHdr->LastModified, sizeof(ArMemHdr->LastModified))
-            .rtrim(" "));
-    OS.flush();
-    uint64_t Offset =
-        reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
+  if (getRawLastModified().getAsInteger(10, Seconds)) {
+    uint64_t Offset = getOffset();
     return malformedError("characters in LastModified field in archive header "
                           "are not all decimal numbers: '" +
-                          Buf + "' for the archive member header at offset " +
+                          getRawLastModified() +
+                          "' for the archive member header at offset " +
                           Twine(Offset));
   }
 
   return sys::toTimePoint(Seconds);
 }
 
-Expected<unsigned> ArchiveMemberHeader::getUID() const {
+// This gets the raw UID from the ArMemHdr->UID field.
+StringRef ArchiveMemberHeader::getRawUID() const {
+  return StringRef(ArMemHdr->UID, sizeof(ArMemHdr->UID)).rtrim(' ');
+}
+
+StringRef BigArchiveMemberHeader::getRawUID() const {
+  return StringRef(ArMemHdr->UID, sizeof(ArMemHdr->UID)).rtrim(' ');
+}
+
+Expected<unsigned> AbstractArchiveMemberHeader::getUID() const {
   unsigned Ret;
-  StringRef User = StringRef(ArMemHdr->UID, sizeof(ArMemHdr->UID)).rtrim(' ');
+  StringRef User = getRawUID();
   if (User.empty())
     return 0;
   if (User.getAsInteger(10, Ret)) {
     std::string Buf;
     raw_string_ostream OS(Buf);
     OS.write_escaped(User);
     OS.flush();
-    uint64_t Offset =
-        reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
+    uint64_t Offset = getOffset();
     return malformedError("characters in UID field in archive header "
                           "are not all decimal numbers: '" +
                           Buf + "' for the archive member header at offset " +
                           Twine(Offset));
   }
   return Ret;
 }
 
-Expected<unsigned> ArchiveMemberHeader::getGID() const {
+// This gets the raw GID from the ArMemHdr->GID field.
+StringRef ArchiveMemberHeader::getRawGID() const {
+  return StringRef(ArMemHdr->GID, sizeof(ArMemHdr->GID)).rtrim(' ');
+}
+
+StringRef BigArchiveMemberHeader::getRawGID() const {
+  return StringRef(ArMemHdr->GID, sizeof(ArMemHdr->GID)).rtrim(' ');
+}
+
+Expected<unsigned> AbstractArchiveMemberHeader::getGID() const {
   unsigned Ret;
-  StringRef Group = StringRef(ArMemHdr->GID, sizeof(ArMemHdr->GID)).rtrim(' ');
+  StringRef Group = getRawGID();
   if (Group.empty())
     return 0;
   if (Group.getAsInteger(10, Ret)) {
-    std::string Buf;
-    raw_string_ostream OS(Buf);
-    OS.write_escaped(Group);
-    OS.flush();
-    uint64_t Offset =
-        reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
+    uint64_t Offset = getOffset();
     return malformedError("characters in GID field in archive header "
                           "are not all decimal numbers: '" +
-                          Buf + "' for the archive member header at offset " +
+                          Group + "' for the archive member header at offset " +
                           Twine(Offset));
   }
   return Ret;
 }
 
 Archive::Child::Child(const Archive *Parent, StringRef Data,
                       uint16_t StartOfFile)
-    : Parent(Parent), Header(Parent, Data.data(), Data.size(), nullptr),
-      Data(Data), StartOfFile(StartOfFile) {}
+    : Parent(Parent), Data(Data), StartOfFile(StartOfFile) {
+  // Create the right concrete archive member as a function of Kind.
+  if (Parent->kind() != K_AIXBIG) {
+    Header = std::make_unique<ArchiveMemberHeader>(
+        ArchiveMemberHeader(Parent, Data.data(), Data.size(), nullptr));
+  } else {
+    Header = std::make_unique<BigArchiveMemberHeader>(
+        BigArchiveMemberHeader(Parent, Data.data(), Data.size(), nullptr));
+  }
+}
 
 Archive::Child::Child(const Archive *Parent, const char *Start, Error *Err)
-    : Parent(Parent),
-      Header(Parent, Start,
-             Parent
-                 ? Parent->getData().size() - (Start - Parent->getData().data())
-                 : 0,
-             Err) {
-  if (!Start)
+    : Parent(Parent) {
+  if (!Start) {
+    Header = nullptr;
     return;
+  }
+
+  // Create the right concrete archive member as a function of Kind.
+  if (Parent->kind() != K_AIXBIG) {
+    Header = std::make_unique<ArchiveMemberHeader>(ArchiveMemberHeader(
+        Parent, Start,
+        Parent ? Parent->getData().size() - (Start - Parent->getData().data())
+               : 0,
+        Err));
+  } else {
+    Header = std::make_unique<BigArchiveMemberHeader>(BigArchiveMemberHeader(
+        Parent, Start,
+        Parent ? Parent->getData().size() - (Start - Parent->getData().data())
+               : 0,
+        Err));
+  }
 
   // If we are pointed to real data, Start is not a nullptr, then there must be
   // a non-null Err pointer available to report malformed data on.  Only in
   // the case sentinel value is being constructed is Err is permitted to be a
   // nullptr.
   assert(Err && "Err can't be nullptr if Start is not a nullptr");
 
   ErrorAsOutParameter ErrAsOutParam(Err);
 
   // If there was an error in the construction of the Header
   // then just return with the error now set.
   if (*Err)
     return;
 
-  uint64_t Size = Header.getSizeOf();
+  uint64_t Size = Header->getSizeOf();
   Data = StringRef(Start, Size);
   Expected<bool> isThinOrErr = isThinMember();
   if (!isThinOrErr) {
     *Err = isThinOrErr.takeError();
     return;
   }
   bool isThin = isThinOrErr.get();
   if (!isThin) {
     Expected<uint64_t> MemberSize = getRawSize();
     if (!MemberSize) {
       *Err = MemberSize.takeError();
       return;
     }
     Size += MemberSize.get();
     Data = StringRef(Start, Size);
   }
 
   // Setup StartOfFile and PaddingBytes.
-  StartOfFile = Header.getSizeOf();
+  StartOfFile = Header->getSizeOf();
   // Don't include attached name.
   Expected<StringRef> NameOrErr = getRawName();
   if (!NameOrErr) {
     *Err = NameOrErr.takeError();
     return;
   }
   StringRef Name = NameOrErr.get();
-  if (Name.startswith("#1/")) {
+
+  if (Parent->kind() == Archive::K_AIXBIG) {
+    // Add name to found the real start of child object, the real start is even
+    // alignment.
+    StartOfFile += ((Name.size() + 1) >> 1) << 1;
+  } else if (Name.startswith("#1/")) {
     uint64_t NameSize;
-    if (Name.substr(3).rtrim(' ').getAsInteger(10, NameSize)) {
-      std::string Buf;
-      raw_string_ostream OS(Buf);
-      OS.write_escaped(Name.substr(3).rtrim(' '));
-      OS.flush();
+    StringRef RawNameSize = Name.substr(3).rtrim(' ');
+    if (RawNameSize.getAsInteger(10, NameSize)) {
       uint64_t Offset = Start - Parent->getData().data();
       *Err = malformedError("long name length characters after the #1/ are "
                             "not all decimal numbers: '" +
-                            Buf + "' for archive member header at offset " +
+                            RawNameSize +
+                            "' for archive member header at offset " +
                             Twine(Offset));
       return;
     }
     StartOfFile += NameSize;
   }
 }
 
 Expected<uint64_t> Archive::Child::getSize() const {
   if (Parent->IsThin)
-    return Header.getSize();
+    return Header->getSize();
   return Data.size() - StartOfFile;
 }
 
 Expected<uint64_t> Archive::Child::getRawSize() const {
-  return Header.getSize();
+  return Header->getSize();
 }
 
 Expected<bool> Archive::Child::isThinMember() const {
-  Expected<StringRef> NameOrErr = Header.getRawName();
+  Expected<StringRef> NameOrErr = Header->getRawName();
   if (!NameOrErr)
     return NameOrErr.takeError();
   StringRef Name = NameOrErr.get();
   return Parent->IsThin && Name != "/" && Name != "//" && Name != "/SYM64/";
 }
 
 Expected<std::string> Archive::Child::getFullName() const {
   Expected<bool> isThin = isThinMember();
Expected<StringRef> Archive::Child::getBuffer() const {
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(FullName);
   if (std::error_code EC = Buf.getError())
     return errorCodeToError(EC);
   Parent->ThinBuffers.push_back(std::move(*Buf));
   return Parent->ThinBuffers.back()->getBuffer();
 }
 
 Expected<Archive::Child> Archive::Child::getNext() const {
+
+  const char *NextLoc = nullptr;
+
+  if (Parent->kind() != K_AIXBIG) {
     size_t SpaceToSkip = Data.size();
     // If it's odd, add 1 to make it even.
     if (SpaceToSkip & 1)
       ++SpaceToSkip;
 
-  const char *NextLoc = Data.data() + SpaceToSkip;
+    NextLoc = Data.data() + SpaceToSkip;
 
     // Check to see if this is at the end of the archive.
     if (NextLoc == Parent->Data.getBufferEnd())
       return Child(nullptr, nullptr, nullptr);
+  } else {
+    // If current child offset is equal to the last ar offset, current child is
+    // the last one.
+    if (Header->getOffset() ==
+        static_cast<const BigArchive *>(Parent)->getLastChildOffset())
+      return Child(nullptr, nullptr, nullptr);
+    else {
+      Expected<uint64_t> NextOffSetOrErr =
+          dyn_cast<BigArchiveMemberHeader>(Header.get())->getNextOffset();
+      if (NextOffSetOrErr)
+        NextLoc = Parent->getData().data() + NextOffSetOrErr.get();
+      else
+        return NextOffSetOrErr.takeError();
+    }
+  }
 
   // Check to see if this is past the end of the archive.
   if (NextLoc > Parent->Data.getBufferEnd()) {
     std::string Msg("offset to next archive member past the end of the archive "
                     "after member ");
     Expected<StringRef> NameOrErr = getName();
     if (!NameOrErr) {
       consumeError(NameOrErr.takeError());
       uint64_t Offset = Data.data() - Parent->getData().data();
       return malformedError(Msg + "at offset " + Twine(Offset));
uint64_t Archive::Child::getChildOffset() const {
   return offset;
 }
 
 Expected<StringRef> Archive::Child::getName() const {
   Expected<uint64_t> RawSizeOrErr = getRawSize();
   if (!RawSizeOrErr)
     return RawSizeOrErr.takeError();
   uint64_t RawSize = RawSizeOrErr.get();
-  Expected<StringRef> NameOrErr = Header.getName(Header.getSizeOf() + RawSize);
+  Expected<StringRef> NameOrErr =
+      Header->getName(Header->getSizeOf() + RawSize);
   if (!NameOrErr)
     return NameOrErr.takeError();
   StringRef Name = NameOrErr.get();
   return Name;
 }
 
 Expected<MemoryBufferRef> Archive::Child::getMemoryBufferRef() const {
   Expected<StringRef> NameOrErr = getName();
Archive::Child::getAsBinary(LLVMContext *Context) const {
 
   auto BinaryOrErr = createBinary(BuffOrErr.get(), Context);
   if (BinaryOrErr)
     return std::move(*BinaryOrErr);
   return BinaryOrErr.takeError();
 }
 
 Expected<std::unique_ptr<Archive>> Archive::create(MemoryBufferRef Source) {
   Error Err = Error::success();
-  std::unique_ptr<Archive> Ret(new Archive(Source, Err));
+
+  Archive *Ret;
+
+  StringRef Buffer = Source.getBuffer();
+
+  if (Buffer.startswith(BigMagic))
+    Ret = new BigArchive(Source, Err);
+  else
+    Ret = new Archive(Source, Err);
+
   if (Err)
     return std::move(Err);
-  return std::move(Ret);
+  return std::unique_ptr<Archive>(Ret);
 }
 
 void Archive::setFirstRegular(const Child &C) {
   FirstRegularData = C.Data;
   FirstRegularStartOfFile = C.StartOfFile;
 }
 
 Archive::Archive(MemoryBufferRef Source, Error &Err)
     : Binary(Binary::ID_Archive, Source) {
   ErrorAsOutParameter ErrAsOutParam(&Err);
   StringRef Buffer = Data.getBuffer();
   // Check for sufficient magic.
   if (Buffer.startswith(ThinMagic)) {
     IsThin = true;
   } else if (Buffer.startswith(Magic)) {
     IsThin = false;
+  } else if (Buffer.startswith(BigMagic)) {
+    Format = K_AIXBIG;
+    IsThin = false;
+    return;
   } else {
     Err = make_error<GenericBinaryError>("file too small to be an archive",
                                          object_error::invalid_file_type);
     return;
   }
 
   // Make sure Format is initialized before any call to
-  // ArchiveMemberHeader::getName() is made.  This could be a valid empty
-  // archive which is the same in all formats.  So claiming it to be gnu to is
-  // fine if not totally correct before we look for a string table or table of
-  // contents.
+  // ArchiveMemberHeader::getName() is made. Read Magic to deal with AIX Big
+  // Archive. Else, this could be a valid empty archive which is the same in all
+  // formats. So claiming it to be gnu to is fine if not totally correct before
+  // we look for a string table or table of contents.
   Format = K_GNU;
 
   // Get the special members.
   child_iterator I = child_begin(Err, false);
   if (Err)
     return;
   child_iterator E = child_end();
 
   // See if this is a valid empty archive and if so return.
Archive::child_iterator Archive::child_begin(Error &Err,
                                              bool SkipInternal) const {
   if (isEmpty())
     return child_end();
 
   if (SkipInternal)
     return child_iterator::itr(
         Child(this, FirstRegularData, FirstRegularStartOfFile), Err);
 
-  const char *Loc = Data.getBufferStart() + strlen(Magic);
+  const char *Loc = Data.getBufferStart() + getFirstChildOffset();
   Child C(this, Loc, &Err);
   if (Err)
     return child_end();
   return child_iterator::itr(C, Err);
 }
 
 Archive::child_iterator Archive::child_end() const {
   return child_iterator::end(Child(nullptr, nullptr, nullptr));
if (SymName == name) {
       else
         return MemberOrErr.takeError();
     }
   }
   return Optional<Child>();
 }
 
 // Returns true if archive file contains no member file.
-bool Archive::isEmpty() const { return Data.getBufferSize() == 8; }
+bool Archive::isEmpty() const {
+  return Data.getBufferSize() == ArchiveMagicLen;
+}
 
 bool Archive::hasSymbolTable() const { return !SymbolTable.empty(); }
+
+BigArchive::BigArchive(MemoryBufferRef Source, Error &Err)
+    : Archive(Source, Err) {
+  ErrorAsOutParameter ErrAsOutParam(&Err);
+  StringRef Buffer = Data.getBuffer();
+  ArFixLenHdr = reinterpret_cast<const BigArFixLenHdrType *>(Buffer.data());
+
+  StringRef RawStringRef = StringRef(ArFixLenHdr->FirstMemberOffset,
+                                     sizeof(ArFixLenHdr->FirstMemberOffset))
+                               .rtrim(' ');
+
+  if (RawStringRef.rtrim(' ').getAsInteger(10, FirstMemberOffset)) {
+    Err = malformedError("malformed aix big archive: first member offset \"" +
+                         RawStringRef + "\" is not a number");
+  }
+
+  RawStringRef = StringRef(ArFixLenHdr->LastMemberOffset,
+                           sizeof(ArFixLenHdr->LastMemberOffset))
+                     .rtrim(' ');
+
+  if (RawStringRef.getAsInteger(10, LastMemberOffset)) {
+    Err = malformedError("malformed aix big archive: last member offset \"" +
+                         RawStringRef + "\" is not a number");
+  }
+
+  child_iterator I = child_begin(Err, false);
+  if (Err)
+    return;
+  child_iterator E = child_end();
+  if (I == E) {
+    Err = Error::success();
+    return;
+  }
+  const Child *C = &*I;
+  setFirstRegular(*C);
+  Err = Error::success();
+  return;
+}

llvm/lib/Object/ArchiveWriter.cpp

static bool isBSDLike(object::Archive::Kind Kind) {
   switch (Kind) {
   case object::Archive::K_GNU:
   case object::Archive::K_GNU64:
     return false;
   case object::Archive::K_BSD:
   case object::Archive::K_DARWIN:
   case object::Archive::K_DARWIN64:
     return true;
+  case object::Archive::K_AIXBIG:
   case object::Archive::K_COFF:
     break;
   }
   llvm_unreachable("not supported for writting");
 }
 
 template <class T>
 static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val) {
   support::endian::write(Out, Val,

 }
 
 static bool is64BitKind(object::Archive::Kind Kind) {
   switch (Kind) {
   case object::Archive::K_GNU:
   case object::Archive::K_BSD:
   case object::Archive::K_DARWIN:
   case object::Archive::K_COFF:
+  case object::Archive::K_AIXBIG:
     return false;
   case object::Archive::K_DARWIN64:
   case object::Archive::K_GNU64:
     return true;
   }
   llvm_unreachable("not supported for writting");
 }
 
 static void
 printMemberHeader(raw_ostream &Out, uint64_t Pos, raw_ostream &StringTable,
                   StringMap<uint64_t> &MemberNames, object::Archive::Kind Kind,
                   bool Thin, const NewArchiveMember &M,
                   sys::TimePoint<std::chrono::seconds> ModTime, uint64_t Size) {
   if (isBSDLike(Kind))

llvm/test/Object/archive-big-extract.test

+## Test extract xcoff object file from AIX big archive.
+# RUN: rm -rf %t && mkdir -p %t/extracted/
+# RUN:  cd %t/extracted/  &&  llvm-ar x %p/Inputs/aix-big-archive.a
+# RUN: diff %t/extracted/empty.o %p/Inputs/aix-big-archive-member.o

llvm/test/Object/archive-big-print.test

+## Test printing an archive created by AIX ar (Big Archive).
+RUN: llvm-ar p %p/Inputs/aix-big-archive.a evenlen | FileCheck %s --check-prefix=AIXBIG --implicit-check-not={{.}}
+AIXBIG: content_of_evenlen

llvm/test/Object/archive-big-read.test

+## Test reading an archive created by AIX ar (Big Archive).
+RUN: env TZ=GMT llvm-ar tv %p/Inputs/aix-big-archive.a | FileCheck %s --strict-whitespace --check-prefix=AIXBIG --implicit-check-not={{.}}
+AIXBIG:      rw-r--r-- 0/0     19 Jan  1 00:00 1970 evenlen
+AIXBIG-NEXT: rw-r--r-- 0/0      7 Jan  1 00:00 1970 oddlen
+AIXBIG-NEXT: rw-r--r-- 0/0    258 Jan  1 00:00 1970 empty.o

llvm/test/tools/llvm-objdump/XCOFF/archive-headers.test

+;; Test llvm-objdump supporting the decode the archive header for xcoff.
+; RUN: llvm-objdump %p/Inputs/big-archive-libtest.a --archive-headers  | FileCheck %s
+
+; CHECK:       {{.*}}big-archive-libtest.a(test_xlclang++.o):    file format aixcoff-rs6000
+; CHECK-NEXT: rw------- 550591/1000499   3154 Tue Oct  5 10:37:23 2021 test_xlclang++.o
+
+; CHECK:       {{.*}}big-archive-libtest.a(test1_gcc.o): file format aixcoff-rs6000
+; CHECK-NEXT: rw------- 550591/1000499   1596 Tue Oct  5 11:11:06 2021 test1_gcc.o

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

static int performOperation(ArchiveOperation Operation,
   // Create or open the archive object.
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(
       ArchiveName, /*IsText=*/false, /*RequiresNullTerminator=*/false);
   std::error_code EC = Buf.getError();
   if (EC && EC != errc::no_such_file_or_directory)
     fail("unable to open '" + ArchiveName + "': " + EC.message());
 
   if (!EC) {
-    Error Err = Error::success();
-    object::Archive Archive(Buf.get()->getMemBufferRef(), Err);
-    failIfError(std::move(Err), "unable to load '" + ArchiveName + "'");
-    if (Archive.isThin())
+    Expected<std::unique_ptr<object::Archive>> ArchiveOrError =
+        object::Archive::create(Buf.get()->getMemBufferRef());
+    if (!ArchiveOrError)
+      failIfError(ArchiveOrError.takeError(),
+                  "unable to load '" + ArchiveName + "'");
+
+    std::unique_ptr<object::Archive> Archive = std::move(ArchiveOrError.get());
+
+    if (Archive->isThin())
       CompareFullPath = true;
-    performOperation(Operation, &Archive, std::move(Buf.get()), NewMembers);
+    performOperation(Operation, Archive.get(), std::move(Buf.get()), NewMembers);
     return 0;
   }
 
   assert(EC == errc::no_such_file_or_directory);
 
   if (!shouldCreateArchive(Operation)) {
     failIfError(EC, Twine("unable to load '") + ArchiveName + "'");
   } else {