[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

658

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

710–716

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

1157

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

1162

There are still unnecessary braces in this if.

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

4

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

3–4

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

2

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 ↗

(On Diff #382677)

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 ↗

(On Diff #381028)

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

137

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

335–338

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

376–384

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.

385–395

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

397–406

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

[DiggerLin]

address comment

[DiggerLin]

llvm/include/llvm/Object/Archive.h

161

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

118

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

120

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

This bit hasn't been addressed.

139

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

149–158

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.

160

Marked as Done but not addressed.

405

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

llvm/lib/Object/Archive.cpp

50

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

53

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

55–56

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

58–63

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

101–102

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

137

Isn't that what the getSizeOf function is for?

138

I don't believe you need this if anymore?

151

Marked as done, but not addressed.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

120

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.

139

thanks

llvm/lib/Object/Archive.cpp

53

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

55–56

thanks

58–63

thanks

101–102

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

710–716

  } 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

41–44

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.

65–67

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.

159–162

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.

183

Please remember to clang-format your changes.

llvm/lib/Object/Archive.cpp

51

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

53

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.

135

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

173

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?

343

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.

343

375–376

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

376–384

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.

385–395

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();
}

710–716

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

41–44

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

41–44

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

41–44

I think I got your suggestion.

[DiggerLin]

llvm/lib/Object/Archive.cpp

51

thanks

53

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

375–376

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

385–395

using the The curiously recurring template pattern (CRTP) .

[DiggerLin]

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

[DiggerLin]

llvm/lib/Object/Archive.cpp

375–376

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

95

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.

131

No need for virtual here. Just delete it.

400

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

llvm/lib/Object/Archive.cpp

65

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

211–212

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.

216

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

222–224

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

423–425

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?

434–435

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

678–683

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

1160

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

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

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.

4

Why hasn't this been addressed yet?

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

3–4

Any reason this hasn't been addressed yet?

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

2

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

This hasn't been addressed.

[DiggerLin]

llvm/lib/Object/Archive.cpp

65

thanks

[DiggerLin]

llvm/include/llvm/Object/Archive.h

35–39

thanks

95

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

131

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

216

thanks

222–224

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

678–683

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

95

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.

95

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?

131

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

400

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

llvm/lib/Object/Archive.cpp

203

evenAlign might be a little clearer as to the intent.

423–425

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?

1166

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

2

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.

95

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

131

sorry for misunderstand your comment.

llvm/lib/Object/Archive.cpp

203

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)

95

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

214

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.

95

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

81

Please remember to clang-format each diff.

105

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

llvm/lib/Object/Archive.cpp

208

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

211

213

I'd probably delete this blank line.

218

Ditto.

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

353

Still not clang-formatted...

369–371

No braces for single line ifs.

425

Still not clang-formatted...

669–673

715

Delete this blank line.

1158

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

1164

Ditto.

1182

This undef is now unnecessary.

[DiggerLin]

llvm/lib/Object/Archive.cpp

1182

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

375

llvm/lib/Object/Archive.cpp

447–448

Related to other comment.

458–463

Related to other comment.

665–672

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

375

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

207

Add TODO, as noted out-of-line.

220

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

1159

Add TODO, as noted out-of-line.

1164

Add TODO, as noted out-of-line.

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

180

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 {
 
+const char ArchiveMagic[] = "!<arch>\n";
+const char ThinArchiveMagic[] = "!<thin>\n";
+const char BigArchiveMagic[] = "<bigaf>\n";
+
 class Archive;
 
-class ArchiveMemberHeader {
+class AbstractArchiveMemberHeader {
+protected:
+  AbstractArchiveMemberHeader(const Archive *Parent) : Parent(Parent){};
+
 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;
+  virtual StringRef getRawAccessMode() const = 0;
+  virtual StringRef getRawLastModified() const = 0;
+  virtual StringRef getRawUID() const = 0;
+  virtual StringRef getRawGID() const = 0;
 
   /// Get the name looking up long names.
-  Expected<StringRef> getName(uint64_t Size) const;
-
-  Expected<uint64_t> getSize() const;
+  virtual Expected<StringRef> getName(uint64_t Size) const = 0;
+  virtual Expected<uint64_t> getSize() const = 0;
+  virtual uint64_t getOffset() const = 0;
+
+  /// Get next file member location.
+  virtual Expected<const char *> getNextChildLoc() const = 0;
+  virtual Expected<bool> isThin() 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 the concrete
+  /// archive type.
+  virtual uint64_t getSizeOf() const = 0;
 
-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;
+  const Archive *Parent;
+};
+
+template <typename T>
+class CommonArchiveMemberHeader : public AbstractArchiveMemberHeader {
+public:
+  CommonArchiveMemberHeader(const Archive *Parent, const T* RawHeaderPtr)
+      : AbstractArchiveMemberHeader(Parent), ArMemHdr(RawHeaderPtr){};
+  StringRef getRawAccessMode() const override;
+  StringRef getRawLastModified() const override;
+  StringRef getRawUID() const override;
+  StringRef getRawGID() const override;
+
+  uint64_t getOffset() const override;
+  uint64_t getSizeOf() const override { return sizeof(T); }
+
+  T const *ArMemHdr;
+};
+
+struct UnixArMemHdrType {
+
+class ArchiveMemberHeader : public CommonArchiveMemberHeader<UnixArMemHdrType> {
+
+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;
+  Expected<const char *> getNextChildLoc() const override;
+  Expected<bool> isThin() const override;
+};
+
+// File Member Header
+struct BigArMemHdrType {
+  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];
+  };
+};
+
+// Define file member header of AIX big archive.
+class BigArchiveMemberHeader
+    : public CommonArchiveMemberHeader<BigArMemHdrType> {
+
+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<uint64_t> getRawNameSize() const;
+
+  Expected<StringRef> getName(uint64_t Size) const override;
+  Expected<uint64_t> getSize() const override;
+  Expected<const char *> getNextChildLoc() const override;
+  Expected<uint64_t> getNextOffset() const;
+  Expected<bool> isThin() const override { return false; }
 };
 
 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 getArchiveMagicLen(); }
 
   std::vector<std::unique_ptr<MemoryBuffer>> takeThinBuffers() {
     return std::move(ThinBuffers);
   }
 
+  AbstractArchiveMemberHeader *
+  createArchiveMemberHeader(const char *RawHeaderPtr, uint64_t Size,
+                            Error *Err) const;
+
+protected:
+  uint64_t getArchiveMagicLen() const;
+  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 FixLenHdr {
+    char Magic[sizeof(BigArchiveMagic) - 1]; ///< 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 FirstChildOffset[20]; ///< Offset to first archive member.
+    char LastChildOffset[20];  ///< Offset to last archive member.
+    char FreeOffset[20];       ///< Offset to first mem on free list.
+  };
+
+  const FixLenHdr *ArFixLenHdr;
+  uint64_t FirstChildOffset = 0;
+  uint64_t LastChildOffset = 0;
+
+public:
+  BigArchive(MemoryBufferRef Source, Error &Err);
+  uint64_t getFirstChildOffset() const override { return FirstChildOffset; }
+  uint64_t getLastChildOffset() const { return LastChildOffset; }
+};
+
 } // end namespace object
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_ARCHIVE_H

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/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/MathExtras.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 <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";
-
 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);
 }
 
+static Error
+createMemberHeaderParseError(const AbstractArchiveMemberHeader *ArMemHeader,
+                             const char *RawHeaderPtr, uint64_t Size) {
+  StringRef Msg("remaining size of archive too small for next archive "
+                "member header ");
+
+  Expected<StringRef> NameOrErr = ArMemHeader->getName(Size);
+  if (NameOrErr)
+    return malformedError(Msg + "for " + *NameOrErr);
+
+  consumeError(NameOrErr.takeError());
+  uint64_t Offset = RawHeaderPtr - ArMemHeader->Parent->getData().data();
+  return malformedError(Msg + "at offset " + Twine(Offset));
+}
+
+template <class T, std::size_t N>
+StringRef getFieldRawString(const T (&Field)[N]) {
+  return StringRef(Field, N).rtrim(" ");
+}
+
+template <class T>
+StringRef CommonArchiveMemberHeader<T>::getRawAccessMode() const {
+  return getFieldRawString(ArMemHdr->AccessMode);
+}
+
+template <class T>
+StringRef CommonArchiveMemberHeader<T>::getRawLastModified() const {
+  return getFieldRawString(ArMemHdr->LastModified);
+}
+
+template <class T> StringRef CommonArchiveMemberHeader<T>::getRawUID() const {
+  return getFieldRawString(ArMemHdr->UID);
+}
+
+template <class T> StringRef CommonArchiveMemberHeader<T>::getRawGID() const {
+  return getFieldRawString(ArMemHdr->GID);
+}
+
+template <class T> uint64_t CommonArchiveMemberHeader<T>::getOffset() const {
+  return reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
+}
+
 ArchiveMemberHeader::ArchiveMemberHeader(const Archive *Parent,
                                          const char *RawHeaderPtr,
                                          uint64_t Size, Error *Err)
-    : Parent(Parent),
-      ArMemHdr(reinterpret_cast<const ArMemHdrType *>(RawHeaderPtr)) {
+    : CommonArchiveMemberHeader<UnixArMemHdrType>(
+          Parent, reinterpret_cast<const UnixArMemHdrType *>(RawHeaderPtr)) {
   if (RawHeaderPtr == nullptr)
     return;
   ErrorAsOutParameter ErrAsOutParam(Err);
 
-  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());
-    }
+  if (Size < getSizeOf()) {
+    *Err = createMemberHeaderParseError(this, RawHeaderPtr, Size);
     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)
+    : CommonArchiveMemberHeader<BigArMemHdrType>(
+          Parent, reinterpret_cast<const BigArMemHdrType *>(RawHeaderPtr)) {
+  if (RawHeaderPtr == nullptr)
+    return;
+  ErrorAsOutParameter ErrAsOutParam(Err);
+
+  if (Size < getSizeOf())
+    *Err = createMemberHeaderParseError(this, RawHeaderPtr, Size);
+}
+
 // 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 =
           reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
       return malformedError("name contains a leading space for archive member "
                             "header at offset " +
                             Twine(Offset));
     }
     EndCond = ' ';
   } else if (ArMemHdr->Name[0] == '/' || ArMemHdr->Name[0] == '#')
     EndCond = ' ';
   else
     EndCond = '/';
   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
+Expected<uint64_t>
+getArchiveMemberDecField(Twine FieldName, const StringRef RawField,
+                         const Archive *Parent,
+                         const AbstractArchiveMemberHeader *MemHeader) {
+  uint64_t Value;
+  if (RawField.getAsInteger(10, Value)) {
+    uint64_t Offset = MemHeader->getOffset();
+    return malformedError("characters in " + FieldName +
+                          " field in archive member header are not "
+                          "all decimal numbers: '" +
+                          RawField +
+                          "' for the archive "
+                          "member header at offset " +
+                          Twine(Offset));
+  }
+  return Value;
+}
+
+Expected<uint64_t>
+getArchiveMemberOctField(Twine FieldName, const StringRef RawField,
+                         const Archive *Parent,
+                         const AbstractArchiveMemberHeader *MemHeader) {
+  uint64_t Value;
+  if (RawField.getAsInteger(8, Value)) {
+    uint64_t Offset = MemHeader->getOffset();
+    return malformedError("characters in " + FieldName +
+                          " field in archive member header are not "
+                          "all octal numbers: '" +
+                          RawField +
+                          "' for the archive "
+                          "member header at offset " +
+                          Twine(Offset));
+  }
+  return Value;
+}
+
+Expected<StringRef> BigArchiveMemberHeader::getRawName() const {
+  Expected<uint64_t> NameLenOrErr = getArchiveMemberDecField(
+      "NameLen", getFieldRawString(ArMemHdr->NameLen), Parent, this);
+  if (!NameLenOrErr)
+    return NameLenOrErr.takeError();
+
+  uint64_t NameLen = NameLenOrErr.get();
+
+  // If name length is odd, pad with '\0' to get an even length. After padding,
+  // there is the name terminator "`\n".
+
+  uint64_t NameLenWithPadding = alignTo(NameLen, 2);
+  StringRef NameTerminator = "`\n";
+  StringRef NameStringWithNameTerminator =
+      StringRef(ArMemHdr->Name, NameLenWithPadding + NameTerminator.size());
+
+  if (!NameStringWithNameTerminator.endswith(NameTerminator)) {
+    uint64_t Offset =
+        reinterpret_cast<const char *>(ArMemHdr->Name + NameLenWithPadding) -
+        Parent->getData().data();
+    return malformedError(
+        "name does not have name terminator \"`\\n\" for archive member"
+        "header at offset " +
+        Twine(Offset));
+  }
+
+  return StringRef(ArMemHdr->Name, NameLen);
+}
+
 // 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 (Size < offsetof(UnixArMemHdrType, Name) + sizeof(ArMemHdr->Name)) {
     uint64_t ArchiveOffset =
         reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
     return malformedError("archive header truncated before the name field "
                           "for archive member header at offset " +
                           Twine(ArchiveOffset));
   }
 
   // The raw name itself can be invalid.
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 {
+  return getRawName();
+}
+
 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 Offset =
-        reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
-    return malformedError("characters in size field in archive header are not "
-                          "all decimal numbers: '" +
-                          Buf +
-                          "' for archive "
-                          "member header at offset " +
-                          Twine(Offset));
-  }
-  return Ret;
+  return getArchiveMemberDecField("size", getFieldRawString(ArMemHdr->Size),
+                                  Parent, this);
+
+Expected<uint64_t> BigArchiveMemberHeader::getSize() const {
+  Expected<uint64_t> SizeOrErr = getArchiveMemberDecField(
+      "size", getFieldRawString(ArMemHdr->Size), Parent, this);
+  if (!SizeOrErr)
+    return SizeOrErr.takeError();
+
+  Expected<uint64_t> NameLenOrErr = getRawNameSize();
+  if (!NameLenOrErr)
+    return NameLenOrErr.takeError();
+
+  return *SizeOrErr + alignTo(*NameLenOrErr,2);
 }
 
-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();
-    uint64_t Offset =
-        reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
-    return malformedError("characters in AccessMode field in archive header "
-                          "are not all decimal numbers: '" +
-                          Buf + "' for the archive member header at offset " +
-                          Twine(Offset));
-  }
-  return static_cast<sys::fs::perms>(Ret);
+Expected<uint64_t> BigArchiveMemberHeader::getRawNameSize() const {
+  return getArchiveMemberDecField(
+      "NameLen", getFieldRawString(ArMemHdr->NameLen), Parent, this);
+
+Expected<uint64_t> BigArchiveMemberHeader::getNextOffset() const {
+  return getArchiveMemberDecField(
+      "NextOffset", getFieldRawString(ArMemHdr->NextOffset), Parent, this);
 }
 
-Expected<sys::TimePoint<std::chrono::seconds>>
-ArchiveMemberHeader::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();
-    return malformedError("characters in LastModified field in archive header "
-                          "are not all decimal numbers: '" +
-                          Buf + "' for the archive member header at offset " +
-                          Twine(Offset));
-  }
+Expected<sys::fs::perms> AbstractArchiveMemberHeader::getAccessMode() const {
+  Expected<uint64_t> AccessModeOrErr =
+      getArchiveMemberOctField("AccessMode", getRawAccessMode(), Parent, this);
+  if (!AccessModeOrErr) {
+    return AccessModeOrErr.takeError();
+  }
+  return static_cast<sys::fs::perms>(*AccessModeOrErr);
 
-  return sys::toTimePoint(Seconds);
+Expected<sys::TimePoint<std::chrono::seconds>>
+AbstractArchiveMemberHeader::getLastModified() const {
+  Expected<uint64_t> SecondsOrErr = getArchiveMemberDecField(
+      "LastModified", getRawLastModified(), Parent, this);
+
+  if (!SecondsOrErr)
+    return SecondsOrErr.takeError();
+
+  return sys::toTimePoint(*SecondsOrErr);
 }
 
-Expected<unsigned> ArchiveMemberHeader::getUID() const {
-  unsigned Ret;
-  StringRef User = StringRef(ArMemHdr->UID, sizeof(ArMemHdr->UID)).rtrim(' ');
+Expected<unsigned> AbstractArchiveMemberHeader::getUID() const {
+  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();
-    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;
+  return getArchiveMemberDecField("UID", User, Parent, this);
 }
 
-Expected<unsigned> ArchiveMemberHeader::getGID() const {
-  unsigned Ret;
-  StringRef Group = StringRef(ArMemHdr->GID, sizeof(ArMemHdr->GID)).rtrim(' ');
+Expected<unsigned> AbstractArchiveMemberHeader::getGID() const {
+  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();
-    return malformedError("characters in GID field in archive header "
-                          "are not all decimal numbers: '" +
-                          Buf + "' for the archive member header at offset " +
-                          Twine(Offset));
-  }
-  return Ret;
+  return getArchiveMemberDecField("GID", Group, Parent, this);
+
+Expected<bool> ArchiveMemberHeader::isThin() const {
+  Expected<StringRef> NameOrErr = getRawName();
+  if (!NameOrErr)
+    return NameOrErr.takeError();
+  StringRef Name = NameOrErr.get();
+  return Parent->isThin() && Name != "/" && Name != "//" && Name != "/SYM64/";
+}
+
+Expected<const char *> ArchiveMemberHeader::getNextChildLoc() const {
+  uint64_t Size = getSizeOf();
+  Expected<bool> isThinOrErr = isThin();
+  if (!isThinOrErr)
+    return isThinOrErr.takeError();
+
+  bool isThin = isThinOrErr.get();
+  if (!isThin) {
+    Expected<uint64_t> MemberSize = getSize();
+    if (!MemberSize)
+      return MemberSize.takeError();
+
+    Size += MemberSize.get();
+  }
+
+  // If Size is odd, add 1 to make it even.
+  const char *NextLoc =
+      reinterpret_cast<const char *>(ArMemHdr) + alignTo(Size,2);
+
+  if (NextLoc == Parent->getMemoryBufferRef().getBufferEnd())
+    return nullptr;
+
+  return NextLoc;
+}
+
+Expected<const char *> BigArchiveMemberHeader::getNextChildLoc() const {
+  if (getOffset() ==
+      static_cast<const BigArchive *>(Parent)->getLastChildOffset())
+    return nullptr;
+
+  Expected<uint64_t> NextOffsetOrErr = getNextOffset();
+  if (!NextOffsetOrErr)
+    return NextOffsetOrErr.takeError();
+  return Parent->getData().data() + NextOffsetOrErr.get();
 }
 
 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) {
+  Header = std::unique_ptr<AbstractArchiveMemberHeader>(
+      Parent->createArchiveMemberHeader(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;
+  }
+
+  Header = std::unique_ptr<AbstractArchiveMemberHeader>(
+      Parent->createArchiveMemberHeader(
+          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) {
+    // The actual start of the file is after the name and any necessary
+    // even-alignment padding.
+    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();
-  if (!NameOrErr)
-    return NameOrErr.takeError();
-  StringRef Name = NameOrErr.get();
-  return Parent->IsThin && Name != "/" && Name != "//" && Name != "/SYM64/";
-}
+Expected<bool> Archive::Child::isThinMember() const { return Header->isThin(); }
 
 Expected<std::string> Archive::Child::getFullName() const {
   Expected<bool> isThin = isThinMember();
   if (!isThin)
     return isThin.takeError();
   assert(isThin.get());
   Expected<StringRef> NameOrErr = getName();
   if (!NameOrErr)
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 {
-  size_t SpaceToSkip = Data.size();
-  // If it's odd, add 1 to make it even.
-  if (SpaceToSkip & 1)
-    ++SpaceToSkip;
+  Expected<const char *> NextLocOrErr = Header->getNextChildLoc();
+  if (!NextLocOrErr)
+    return NextLocOrErr.takeError();
 
-  const char *NextLoc = Data.data() + SpaceToSkip;
+  const char *NextLoc = *NextLocOrErr;
 
-  // Check to see if this is at the end of the archive.
-  if (NextLoc == Parent->Data.getBufferEnd())
+  if (NextLoc == nullptr)
     return Child(nullptr, nullptr, nullptr);
 
-  // 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));
     } else
       return malformedError(Msg + NameOrErr.get());
   }
 
   Error Err = Error::success();
   Child Ret(Parent, NextLoc, &Err);
   if (Err)
     return std::move(Err);
   return Ret;
 }
 
 uint64_t Archive::Child::getChildOffset() const {
   const char *a = Parent->Data.getBuffer().data();
   const char *c = Data.data();
   uint64_t offset = c - a;
   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));
+  std::unique_ptr<Archive> Ret;
+  StringRef Buffer = Source.getBuffer();
+
+  if (Buffer.startswith(BigArchiveMagic))
+    Ret = std::make_unique<BigArchive>(Source, Err);
+  else
+    Ret = std::make_unique<Archive>(Source, Err);
+
   if (Err)
     return std::move(Err);
-  return std::move(Ret);
+  return Ret;
+}
+
+AbstractArchiveMemberHeader *
+Archive::createArchiveMemberHeader(const char *RawHeaderPtr, uint64_t Size,
+                                   Error *Err) const {
+  ErrorAsOutParameter ErrAsOutParam(Err);
+  if (kind() != K_AIXBIG) {
+    return new ArchiveMemberHeader(this, RawHeaderPtr, Size, Err);
+  } else {
+    return new BigArchiveMemberHeader(this, RawHeaderPtr, Size, Err);
+  }
+}
+
+uint64_t Archive::getArchiveMagicLen() const {
+  if (isThin())
+    return sizeof(ThinArchiveMagic) - 1;
+
+  if (Kind() == K_AIXBIG)
+    return sizeof(BigArchiveMagic) - 1;
+
+  return sizeof(ArchiveMagic) - 1;
 }
 
 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)) {
+  if (Buffer.startswith(ThinArchiveMagic)) {
     IsThin = true;
-  } else if (Buffer.startswith(Magic)) {
+  } else if (Buffer.startswith(ArchiveMagic)) {
+    IsThin = false;
+  } else if (Buffer.startswith(BigArchiveMagic)) {
+    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.
+
   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() == getArchiveMagicLen();
+}
 
 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 FixLenHdr *>(Buffer.data());
+
+  StringRef RawOffset = getFieldRawString(ArFixLenHdr->FirstChildOffset);
+
+  if (RawOffset.getAsInteger(10, FirstChildOffset))
+    Err = malformedError("malformed AIX big archive: first member offset \"" +
+                         RawOffset + "\" is not a number");
+
+  RawOffset = getFieldRawString(ArFixLenHdr->LastChildOffset);
+
+  if (RawOffset.getAsInteger(10, LastChildOffset))
+    Err = malformedError("malformed AIX big archive: last member offset \"" +
+                         RawOffset + "\" 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;
+  }
+  setFirstRegular(*I);
+  Err = Error::success();
+  return;
+}
+
+#undef getFieldRawString

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/ && cd %t/extracted/ 
+# RUN: llvm-ar x %p/Inputs/aix-big-archive.a
+# RUN: echo "content_of_evenlen" > evenlen_1
+# RUN: cmp evenlen evenlen_1

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 --implicit-check-not={{.}}
+# CHECK: content_of_evenlen

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

+## Test reading an AIX big archive member list. 
+# RUN: env TZ=GMT llvm-ar tv %p/Inputs/aix-big-archive.a | FileCheck %s --strict-whitespace --implicit-check-not={{.}}
+
+# CHECK:       rw-r--r-- 550591/1000499      7 Jan  5 17:33 2022 oddlen
+# CHECK-NEXT:  rw-r--r-- 550591/1000499     19 Jan  5 17:33 2022 evenlen

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

 ## These test checks that llvm-objdump will not crash with malformed archive
 ## files. The check line is not all that important but the bug fixes to
 ## make sure llvm-objdump is robust is what matters.
 
 ## Check we report an error when unable to read the size field on an archive as an integer.
 ## Check two cases: a) the first member is valid, but the second is not, and b) both are invalid.
 
 # RUN: yaml2obj --docnum=1 -DFIRST="Size: '1%'" %s -o %t.libbogus1a.a
 # RUN: not llvm-objdump --macho --archive-headers %t.libbogus1a.a 2>&1 | \
 # RUN:   FileCheck -check-prefix=BOGUS1 -DVAL='1%' -DOFFSET=8 -DFILE=%t.libbogus1a.a %s
 
 # RUN: yaml2obj --docnum=1 %s -o %t.libbogus1b.a
 # RUN: not llvm-objdump --macho --archive-headers %t.libbogus1b.a 2>&1 | \
 # RUN:   FileCheck -check-prefix=BOGUS1 -DVAL=10% -DOFFSET=68 -DFILE=%t.libbogus1b.a %s
 
-# BOGUS1: '[[FILE]]': truncated or malformed archive (characters in size field in archive header are not all decimal numbers: '[[VAL]]' for archive member header at offset [[OFFSET]])
+# BOGUS1: '[[FILE]]': truncated or malformed archive (characters in size field in archive member header are not all decimal numbers: '[[VAL]]' for the archive member header at offset [[OFFSET]])
 
 --- !Arch
 Members:
   - [[FIRST={}]]
   - Size: '10%'
 
 ## Check we report an error when an archive is truncated and are unable to skip the data of a member and read the next one.
 
Members:
   - Name: '/1'
 
 ## Check we report an error when the characters in the UID field of a member header are not all decimal numbers.
 
 # RUN: yaml2obj --docnum=10 %s -o %t.libbogus10.a
 # RUN: not llvm-objdump --macho --archive-headers \
 # RUN:   %t.libbogus10.a 2>&1 | FileCheck -check-prefix=BOGUS10 -DFILE=%t.libbogus10.a %s 
 
-# BOGUS10: [[FILE]](hello.c): truncated or malformed archive (characters in UID field in archive header are not all decimal numbers: '~97&' for the archive member header at offset 8)
+# BOGUS10: [[FILE]](hello.c): truncated or malformed archive (characters in UID field in archive member header are not all decimal numbers: '~97&' for the archive member header at offset 8)
 
 --- !Arch
 Members:
   - Name: hello.c
     UID:  '~97&'
 
 ## Check we report an error when the characters in the GID field of a member header are not all decimal numbers.
 
 # RUN: yaml2obj --docnum=11 %s -o %t.libbogus11.a
 # RUN: not llvm-objdump --macho --archive-headers \
 # RUN:   %t.libbogus11.a 2>&1 | FileCheck -check-prefix=BOGUS11 -DFILE=%t.libbogus11.a %s 
 
-# BOGUS11: [[FILE]](hello.c): truncated or malformed archive (characters in GID field in archive header are not all decimal numbers: '#55!' for the archive member header at offset 8)
+# BOGUS11: [[FILE]](hello.c): truncated or malformed archive (characters in GID field in archive member header are not all decimal numbers: '#55!' for the archive member header at offset 8)
 
 --- !Arch
 Members:
   - Name: hello.c
     GID:  '#55!'
 
-## Check we report an error when the characters in the AccessMode field of a member header are not all decimal numbers.
+## Check we report an error when the characters in the AccessMode field of a member header are not all octal numbers.
 
 # RUN: yaml2obj --docnum=12 %s -o %t.libbogus12.a
 # RUN: not llvm-objdump --macho --archive-headers \
 # RUN:   %t.libbogus12.a 2>&1 | FileCheck -check-prefix=BOGUS12 -DFILE=%t.libbogus12.a %s 
 
-# BOGUS12: [[FILE]](hello.c): truncated or malformed archive (characters in AccessMode field in archive header are not all decimal numbers: 'Feed' for the archive member header at offset 8)
+# BOGUS12: [[FILE]](hello.c): truncated or malformed archive (characters in AccessMode field in archive member header are not all octal numbers: 'Feed' for the archive member header at offset 8)
 
 --- !Arch
 Members:
   - Name:       hello.c
     AccessMode: 'Feed'
 
 ## Check we report an error when the characters in the LastModified field of a member header are not all decimal numbers.
 
 # RUN: yaml2obj --docnum=13 %s -o %t.libbogus13.a
 # RUN: llvm-objdump --macho --archive-headers %t.libbogus13.a 2>&1 | \
 # RUN:   FileCheck -check-prefix=BOGUS13A %s 
 
 # BOGUS13A: ----------  0/0 0 (date: "1foobar273" contains non-decimal chars) hello.c
 
 --- !Arch
 Members:
   - Name:         hello.c
     LastModified: '1foobar273'
 
 # RUN: not llvm-ar tv %t.libbogus13.a 2>&1 | \
 # RUN:   FileCheck -check-prefix=BOGUS13B %s 
 
-# BOGUS13B: error: truncated or malformed archive (characters in LastModified field in archive header are not all decimal numbers: '1foobar273' for the archive member header at offset 8)
+# BOGUS13B: error: truncated or malformed archive (characters in LastModified field in archive member header are not all decimal numbers: '1foobar273' for the archive member header at offset 8)

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 {