Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- LibDriver.cpp - lib.exe-compatible driver --------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// Defines an interface to a lib.exe-compatible driver that also understands
10
// bitcode files. Used by llvm-lib and lld-link /lib.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#include "llvm/ToolDrivers/llvm-lib/LibDriver.h"
15
#include "llvm/ADT/STLExtras.h"
16
#include "llvm/BinaryFormat/COFF.h"
17
#include "llvm/BinaryFormat/Magic.h"
18
#include "llvm/Bitcode/BitcodeReader.h"
19
#include "llvm/Object/ArchiveWriter.h"
20
#include "llvm/Object/COFF.h"
21
#include "llvm/Object/WindowsMachineFlag.h"
22
#include "llvm/Option/Arg.h"
23
#include "llvm/Option/ArgList.h"
24
#include "llvm/Option/Option.h"
25
#include "llvm/Support/CommandLine.h"
26
#include "llvm/Support/Path.h"
27
#include "llvm/Support/Process.h"
28
#include "llvm/Support/StringSaver.h"
29
#include "llvm/Support/raw_ostream.h"
30
31
using namespace llvm;
32
33
namespace {
34
35
enum {
36
  OPT_INVALID = 0,
37
#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
38
#include "Options.inc"
39
#undef OPTION
40
};
41
42
#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
43
#include "Options.inc"
44
#undef PREFIX
45
46
static const opt::OptTable::Info InfoTable[] = {
47
#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
48
  {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
49
   X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
50
#include "Options.inc"
51
#undef OPTION
52
};
53
54
class LibOptTable : public opt::OptTable {
55
public:
56
37
  LibOptTable() : OptTable(InfoTable, true) {}
57
};
58
59
}
60
61
static std::string getOutputPath(opt::InputArgList *Args,
62
28
                                 const NewArchiveMember &FirstMember) {
63
28
  if (auto *Arg = Args->getLastArg(OPT_out))
64
23
    return Arg->getValue();
65
5
  SmallString<128> Val = StringRef(FirstMember.Buf->getBufferIdentifier());
66
5
  sys::path::replace_extension(Val, ".lib");
67
5
  return Val.str();
68
5
}
69
70
static std::vector<StringRef> getSearchPaths(opt::InputArgList *Args,
71
33
                                             StringSaver &Saver) {
72
33
  std::vector<StringRef> Ret;
73
33
  // Add current directory as first item of the search path.
74
33
  Ret.push_back("");
75
33
76
33
  // Add /libpath flags.
77
33
  for (auto *Arg : Args->filtered(OPT_libpath))
78
5
    Ret.push_back(Arg->getValue());
79
33
80
33
  // Add $LIB.
81
33
  Optional<std::string> EnvOpt = sys::Process::GetEnv("LIB");
82
33
  if (!EnvOpt.hasValue())
83
31
    return Ret;
84
2
  StringRef Env = Saver.save(*EnvOpt);
85
5
  while (!Env.empty()) {
86
3
    StringRef Path;
87
3
    std::tie(Path, Env) = Env.split(';');
88
3
    Ret.push_back(Path);
89
3
  }
90
2
  return Ret;
91
2
}
92
93
46
static std::string findInputFile(StringRef File, ArrayRef<StringRef> Paths) {
94
51
  for (StringRef Dir : Paths) {
95
51
    SmallString<128> Path = Dir;
96
51
    sys::path::append(Path, File);
97
51
    if (sys::fs::exists(Path))
98
46
      return Path.str().str();
99
51
  }
100
46
  
return ""0
;
101
46
}
102
103
7
static void fatalOpenError(llvm::Error E, Twine File) {
104
7
  if (!E)
105
7
    return;
106
0
  handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
107
0
    llvm::errs() << "error opening '" << File << "': " << EIB.message() << '\n';
108
0
    exit(1);
109
0
  });
110
0
}
111
112
1
static void doList(opt::InputArgList& Args) {
113
1
  // lib.exe prints the contents of the first archive file.
114
1
  std::unique_ptr<MemoryBuffer> B;
115
3
  for (auto *Arg : Args.filtered(OPT_INPUT)) {
116
3
    // Create or open the archive object.
117
3
    ErrorOr<std::unique_ptr<MemoryBuffer>> MaybeBuf =
118
3
        MemoryBuffer::getFile(Arg->getValue(), -1, false);
119
3
    fatalOpenError(errorCodeToError(MaybeBuf.getError()), Arg->getValue());
120
3
121
3
    if (identify_magic(MaybeBuf.get()->getBuffer()) == file_magic::archive) {
122
1
      B = std::move(MaybeBuf.get());
123
1
      break;
124
1
    }
125
3
  }
126
1
127
1
  // lib.exe doesn't print an error if no .lib files are passed.
128
1
  if (!B)
129
0
    return;
130
1
131
1
  Error Err = Error::success();
132
1
  object::Archive Archive(B.get()->getMemBufferRef(), Err);
133
1
  fatalOpenError(std::move(Err), B->getBufferIdentifier());
134
1
135
2
  for (auto &C : Archive.children(Err)) {
136
2
    Expected<StringRef> NameOrErr = C.getName();
137
2
    fatalOpenError(NameOrErr.takeError(), B->getBufferIdentifier());
138
2
    StringRef Name = NameOrErr.get();
139
2
    llvm::outs() << Name << '\n';
140
2
  }
141
1
  fatalOpenError(std::move(Err), B->getBufferIdentifier());
142
1
}
143
144
37
int llvm::libDriverMain(ArrayRef<const char *> ArgsArr) {
145
37
  BumpPtrAllocator Alloc;
146
37
  StringSaver Saver(Alloc);
147
37
148
37
  // Parse command line arguments.
149
37
  SmallVector<const char *, 20> NewArgs(ArgsArr.begin(), ArgsArr.end());
150
37
  cl::ExpandResponseFiles(Saver, cl::TokenizeWindowsCommandLine, NewArgs);
151
37
  ArgsArr = NewArgs;
152
37
153
37
  LibOptTable Table;
154
37
  unsigned MissingIndex;
155
37
  unsigned MissingCount;
156
37
  opt::InputArgList Args =
157
37
      Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount);
158
37
  if (MissingCount) {
159
0
    llvm::errs() << "missing arg value for \""
160
0
                 << Args.getArgString(MissingIndex) << "\", expected "
161
0
                 << MissingCount
162
0
                 << (MissingCount == 1 ? " argument.\n" : " arguments.\n");
163
0
    return 1;
164
0
  }
165
37
  for (auto *Arg : Args.filtered(OPT_UNKNOWN))
166
0
    llvm::errs() << "ignoring unknown argument: " << Arg->getAsString(Args)
167
0
                 << "\n";
168
37
169
37
  // Handle /help
170
37
  if (Args.hasArg(OPT_help)) {
171
2
    Table.PrintHelp(outs(), "llvm-lib [options] file...", "LLVM Lib");
172
2
    return 0;
173
2
  }
174
35
175
35
  // If no input files, silently do nothing to match lib.exe.
176
35
  if (!Args.hasArgNoClaim(OPT_INPUT))
177
1
    return 0;
178
34
179
34
  if (Args.hasArg(OPT_lst)) {
180
1
    doList(Args);
181
1
    return 0;
182
1
  }
183
33
184
33
  std::vector<StringRef> SearchPaths = getSearchPaths(&Args, Saver);
185
33
186
33
  COFF::MachineTypes LibMachine = COFF::IMAGE_FILE_MACHINE_UNKNOWN;
187
33
  std::string LibMachineSource;
188
33
  if (auto *Arg = Args.getLastArg(OPT_machine)) {
189
1
    LibMachine = getMachineType(Arg->getValue());
190
1
    if (LibMachine == COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
191
0
      llvm::errs() << "unknown /machine: arg " << Arg->getValue() << '\n';
192
0
      return 1;
193
0
    }
194
1
    LibMachineSource =
195
1
        std::string(" (from '/machine:") + Arg->getValue() + "' flag)";
196
1
  }
197
33
198
33
  // Create a NewArchiveMember for each input file.
199
33
  std::vector<NewArchiveMember> Members;
200
46
  for (auto *Arg : Args.filtered(OPT_INPUT)) {
201
46
    std::string Path = findInputFile(Arg->getValue(), SearchPaths);
202
46
    if (Path.empty()) {
203
0
      llvm::errs() << Arg->getValue() << ": no such file or directory\n";
204
0
      return 1;
205
0
    }
206
46
207
46
    Expected<NewArchiveMember> MOrErr =
208
46
        NewArchiveMember::getFile(Saver.save(Path), /*Deterministic=*/true);
209
46
    if (!MOrErr) {
210
0
      handleAllErrors(MOrErr.takeError(), [&](const ErrorInfoBase &EIB) {
211
0
        llvm::errs() << Arg->getValue() << ": " << EIB.message() << "\n";
212
0
      });
213
0
      return 1;
214
0
    }
215
46
216
46
    file_magic Magic = identify_magic(MOrErr->Buf->getBuffer());
217
46
    if (Magic != file_magic::coff_object && 
Magic != file_magic::bitcode15
&&
218
46
        
Magic != file_magic::windows_resource4
) {
219
1
      llvm::errs() << Arg->getValue()
220
1
                   << ": not a COFF object, bitcode or resource file\n";
221
1
      return 1;
222
1
    }
223
45
224
45
    // Check that all input files have the same machine type.
225
45
    // Mixing normal objects and LTO bitcode files is fine as long as they
226
45
    // have the same machine type.
227
45
    // Doing this here duplicates the header parsing work that writeArchive()
228
45
    // below does, but it's not a lot of work and it's a bit awkward to do
229
45
    // in writeArchive() which needs to support many tools, can't assume the
230
45
    // input is COFF, and doesn't have a good way to report errors.
231
45
    COFF::MachineTypes FileMachine = COFF::IMAGE_FILE_MACHINE_UNKNOWN;
232
45
    if (Magic == file_magic::coff_object) {
233
31
      std::error_code EC;
234
31
      object::COFFObjectFile Obj(*MOrErr->Buf, EC);
235
31
      if (EC) {
236
0
        llvm::errs() << Arg->getValue() << ": failed to open: " << EC.message()
237
0
                     << '\n';
238
0
        return 1;
239
0
      }
240
31
      uint16_t Machine = Obj.getMachine();
241
31
      if (Machine != COFF::IMAGE_FILE_MACHINE_I386 &&
242
31
          
Machine != COFF::IMAGE_FILE_MACHINE_AMD6427
&&
243
31
          
Machine != COFF::IMAGE_FILE_MACHINE_ARMNT0
&&
244
31
          
Machine != COFF::IMAGE_FILE_MACHINE_ARM640
) {
245
0
        llvm::errs() << Arg->getValue() << ": unknown machine: " << Machine
246
0
                     << '\n';
247
0
        return 1;
248
0
      }
249
31
      FileMachine = static_cast<COFF::MachineTypes>(Machine);
250
31
    } else 
if (14
Magic == file_magic::bitcode14
) {
251
11
      Expected<std::string> TripleStr = getBitcodeTargetTriple(*MOrErr->Buf);
252
11
      if (!TripleStr) {
253
0
        llvm::errs() << Arg->getValue()
254
0
                     << ": failed to get target triple from bitcode\n";
255
0
        return 1;
256
0
      }
257
11
      switch (Triple(*TripleStr).getArch()) {
258
11
      case Triple::x86:
259
6
        FileMachine = COFF::IMAGE_FILE_MACHINE_I386;
260
6
        break;
261
11
      case Triple::x86_64:
262
4
        FileMachine = COFF::IMAGE_FILE_MACHINE_AMD64;
263
4
        break;
264
11
      case Triple::arm:
265
0
        FileMachine = COFF::IMAGE_FILE_MACHINE_ARMNT;
266
0
        break;
267
11
      case Triple::aarch64:
268
1
        FileMachine = COFF::IMAGE_FILE_MACHINE_ARM64;
269
1
        break;
270
11
      default:
271
0
        llvm::errs() << Arg->getValue() << ": unknown arch in target triple "
272
0
                     << *TripleStr << '\n';
273
0
        return 1;
274
45
      }
275
45
    }
276
45
277
45
    // FIXME: Once lld-link rejects multiple resource .obj files:
278
45
    // Call convertResToCOFF() on .res files and add the resulting
279
45
    // COFF file to the .lib output instead of adding the .res file, and remove
280
45
    // this check. See PR42180.
281
45
    if (FileMachine != COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
282
42
      if (LibMachine == COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
283
30
        LibMachine = FileMachine;
284
30
        LibMachineSource = std::string(" (inferred from earlier file '") +
285
30
                           Arg->getValue() + "')";
286
30
      } else 
if (12
LibMachine != FileMachine12
) {
287
4
        llvm::errs() << Arg->getValue() << ": file machine type "
288
4
                     << machineToStr(FileMachine)
289
4
                     << " conflicts with library machine type "
290
4
                     << machineToStr(LibMachine) << LibMachineSource << '\n';
291
4
        return 1;
292
4
      }
293
41
    }
294
41
295
41
    Members.emplace_back(std::move(*MOrErr));
296
41
  }
297
33
298
33
  // Create an archive file.
299
33
  std::string OutputPath = getOutputPath(&Args, Members[0]);
300
28
  // llvm-lib uses relative paths for both regular and thin archives, unlike
301
28
  // standard GNU ar, which only uses relative paths for thin archives and
302
28
  // basenames for regular archives.
303
38
  for (NewArchiveMember &Member : Members) {
304
38
    if (sys::path::is_relative(Member.MemberName)) {
305
6
      Expected<std::string> PathOrErr =
306
6
          computeArchiveRelativePath(OutputPath, Member.MemberName);
307
6
      if (PathOrErr)
308
6
        Member.MemberName = Saver.save(*PathOrErr);
309
6
    }
310
38
  }
311
28
312
28
  if (Error E =
313
0
          writeArchive(OutputPath, Members,
314
0
                       /*WriteSymtab=*/true, object::Archive::K_GNU,
315
0
                       /*Deterministic*/ true, Args.hasArg(OPT_llvmlibthin))) {
316
0
    handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
317
0
      llvm::errs() << OutputPath << ": " << EI.message() << "\n";
318
0
    });
319
0
    return 1;
320
0
  }
321
28
322
28
  return 0;
323
28
}