llvm/tools/llvm-reduce/ReducerWorkItem.cpp

   1 //===- ReducerWorkItem.cpp - Wrapper for Module and MachineFunction -------===//
   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 #include "ReducerWorkItem.h"
  10 #include "TestRunner.h"
  11 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
  12 #include "llvm/Analysis/ProfileSummaryInfo.h"
  13 #include "llvm/Bitcode/BitcodeReader.h"
  14 #include "llvm/Bitcode/BitcodeWriter.h"
  15 #include "llvm/CodeGen/CommandFlags.h"
  16 #include "llvm/CodeGen/MIRParser/MIRParser.h"
  17 #include "llvm/CodeGen/MIRPrinter.h"
  18 #include "llvm/CodeGen/MachineDominators.h"
  19 #include "llvm/CodeGen/MachineFrameInfo.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/CodeGen/MachineFunctionPass.h"
  22 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  23 #include "llvm/CodeGen/MachineModuleInfo.h"
  24 #include "llvm/CodeGen/MachineRegisterInfo.h"
  25 #include "llvm/CodeGen/TargetInstrInfo.h"
  26 #include "llvm/IR/Constants.h"
  27 #include "llvm/IR/Instructions.h"
  28 #include "llvm/IR/ModuleSummaryIndex.h"
  29 #include "llvm/IR/Operator.h"
  30 #include "llvm/IR/Verifier.h"
  31 #include "llvm/IRReader/IRReader.h"
  32 #include "llvm/MC/TargetRegistry.h"
  33 #include "llvm/Passes/PassBuilder.h"
  34 #include "llvm/Support/MemoryBufferRef.h"
  35 #include "llvm/Support/SourceMgr.h"
  36 #include "llvm/Support/TargetSelect.h"
  37 #include "llvm/Support/ToolOutputFile.h"
  38 #include "llvm/Support/WithColor.h"
  39 #include "llvm/Target/TargetMachine.h"
  40 #include "llvm/TargetParser/Host.h"
  41 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
  42 #include "llvm/Transforms/Utils/Cloning.h"
  43 #include <optional>
  44
  45 using namespace llvm;
  46
  47 ReducerWorkItem::ReducerWorkItem() = default;
  48 ReducerWorkItem::~ReducerWorkItem() = default;
  49
  50 extern cl::OptionCategory LLVMReduceOptions;
  51 static cl::opt<std::string> TargetTriple("mtriple",
  52                                          cl::desc("Set the target triple"),
  53                                          cl::cat(LLVMReduceOptions));
  54
  55 static cl::opt<bool> TmpFilesAsBitcode(
  56     "write-tmp-files-as-bitcode",
  57     cl::desc("Always write temporary files as bitcode instead of textual IR"),
  58     cl::init(false), cl::cat(LLVMReduceOptions));
  59
  60 static void cloneFrameInfo(
  61     MachineFrameInfo &DstMFI, const MachineFrameInfo &SrcMFI,
  62     const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB) {
  63   DstMFI.setFrameAddressIsTaken(SrcMFI.isFrameAddressTaken());
  64   DstMFI.setReturnAddressIsTaken(SrcMFI.isReturnAddressTaken());
  65   DstMFI.setHasStackMap(SrcMFI.hasStackMap());
  66   DstMFI.setHasPatchPoint(SrcMFI.hasPatchPoint());
  67   DstMFI.setUseLocalStackAllocationBlock(
  68       SrcMFI.getUseLocalStackAllocationBlock());
  69   DstMFI.setOffsetAdjustment(SrcMFI.getOffsetAdjustment());
  70
  71   DstMFI.ensureMaxAlignment(SrcMFI.getMaxAlign());
  72   assert(DstMFI.getMaxAlign() == SrcMFI.getMaxAlign() &&
  73          "we need to set exact alignment");
  74
  75   DstMFI.setAdjustsStack(SrcMFI.adjustsStack());
  76   DstMFI.setHasCalls(SrcMFI.hasCalls());
  77   DstMFI.setHasOpaqueSPAdjustment(SrcMFI.hasOpaqueSPAdjustment());
  78   DstMFI.setHasCopyImplyingStackAdjustment(
  79       SrcMFI.hasCopyImplyingStackAdjustment());
  80   DstMFI.setHasVAStart(SrcMFI.hasVAStart());
  81   DstMFI.setHasMustTailInVarArgFunc(SrcMFI.hasMustTailInVarArgFunc());
  82   DstMFI.setHasTailCall(SrcMFI.hasTailCall());
  83
  84   if (SrcMFI.isMaxCallFrameSizeComputed())
  85     DstMFI.setMaxCallFrameSize(SrcMFI.getMaxCallFrameSize());
  86
  87   DstMFI.setCVBytesOfCalleeSavedRegisters(
  88       SrcMFI.getCVBytesOfCalleeSavedRegisters());
  89
  90   if (MachineBasicBlock *SavePt = SrcMFI.getSavePoint())
  91     DstMFI.setSavePoint(Src2DstMBB.find(SavePt)->second);
  92   if (MachineBasicBlock *RestorePt = SrcMFI.getRestorePoint())
  93     DstMFI.setRestorePoint(Src2DstMBB.find(RestorePt)->second);
  94
  95
  96   auto CopyObjectProperties = [](MachineFrameInfo &DstMFI,
  97                                  const MachineFrameInfo &SrcMFI, int FI) {
  98     if (SrcMFI.isStatepointSpillSlotObjectIndex(FI))
  99       DstMFI.markAsStatepointSpillSlotObjectIndex(FI);
 100     DstMFI.setObjectSSPLayout(FI, SrcMFI.getObjectSSPLayout(FI));
 101     DstMFI.setObjectZExt(FI, SrcMFI.isObjectZExt(FI));
 102     DstMFI.setObjectSExt(FI, SrcMFI.isObjectSExt(FI));
 103   };
 104
 105   for (int i = 0, e = SrcMFI.getNumObjects() - SrcMFI.getNumFixedObjects();
 106        i != e; ++i) {
 107     int NewFI;
 108
 109     assert(!SrcMFI.isFixedObjectIndex(i));
 110     if (SrcMFI.isVariableSizedObjectIndex(i)) {
 111       NewFI = DstMFI.CreateVariableSizedObject(SrcMFI.getObjectAlign(i),
 112                                                SrcMFI.getObjectAllocation(i));
 113     } else {
 114       NewFI = DstMFI.CreateStackObject(
 115           SrcMFI.getObjectSize(i), SrcMFI.getObjectAlign(i),
 116           SrcMFI.isSpillSlotObjectIndex(i), SrcMFI.getObjectAllocation(i),
 117           SrcMFI.getStackID(i));
 118       DstMFI.setObjectOffset(NewFI, SrcMFI.getObjectOffset(i));
 119     }
 120
 121     CopyObjectProperties(DstMFI, SrcMFI, i);
 122
 123     (void)NewFI;
 124     assert(i == NewFI && "expected to keep stable frame index numbering");
 125   }
 126
 127   // Copy the fixed frame objects backwards to preserve frame index numbers,
 128   // since CreateFixedObject uses front insertion.
 129   for (int i = -1; i >= (int)-SrcMFI.getNumFixedObjects(); --i) {
 130     assert(SrcMFI.isFixedObjectIndex(i));
 131     int NewFI = DstMFI.CreateFixedObject(
 132       SrcMFI.getObjectSize(i), SrcMFI.getObjectOffset(i),
 133       SrcMFI.isImmutableObjectIndex(i), SrcMFI.isAliasedObjectIndex(i));
 134     CopyObjectProperties(DstMFI, SrcMFI, i);
 135
 136     (void)NewFI;
 137     assert(i == NewFI && "expected to keep stable frame index numbering");
 138   }
 139
 140   for (unsigned I = 0, E = SrcMFI.getLocalFrameObjectCount(); I < E; ++I) {
 141     auto LocalObject = SrcMFI.getLocalFrameObjectMap(I);
 142     DstMFI.mapLocalFrameObject(LocalObject.first, LocalObject.second);
 143   }
 144
 145   DstMFI.setCalleeSavedInfo(SrcMFI.getCalleeSavedInfo());
 146
 147   if (SrcMFI.hasStackProtectorIndex()) {
 148     DstMFI.setStackProtectorIndex(SrcMFI.getStackProtectorIndex());
 149   }
 150
 151   // FIXME: Needs test, missing MIR serialization.
 152   if (SrcMFI.hasFunctionContextIndex()) {
 153     DstMFI.setFunctionContextIndex(SrcMFI.getFunctionContextIndex());
 154   }
 155 }
 156
 157 static void cloneJumpTableInfo(
 158     MachineFunction &DstMF, const MachineJumpTableInfo &SrcJTI,
 159     const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB) {
 160
 161   auto *DstJTI = DstMF.getOrCreateJumpTableInfo(SrcJTI.getEntryKind());
 162
 163   std::vector<MachineBasicBlock *> DstBBs;
 164
 165   for (const MachineJumpTableEntry &Entry : SrcJTI.getJumpTables()) {
 166     for (MachineBasicBlock *X : Entry.MBBs)
 167       DstBBs.push_back(Src2DstMBB.find(X)->second);
 168
 169     DstJTI->createJumpTableIndex(DstBBs);
 170     DstBBs.clear();
 171   }
 172 }
 173
 174 static void cloneMemOperands(MachineInstr &DstMI, MachineInstr &SrcMI,
 175                              MachineFunction &SrcMF, MachineFunction &DstMF) {
 176   // The new MachineMemOperands should be owned by the new function's
 177   // Allocator.
 178   PseudoSourceValueManager &PSVMgr = DstMF.getPSVManager();
 179
 180   // We also need to remap the PseudoSourceValues from the new function's
 181   // PseudoSourceValueManager.
 182   SmallVector<MachineMemOperand *, 2> NewMMOs;
 183   for (MachineMemOperand *OldMMO : SrcMI.memoperands()) {
 184     MachinePointerInfo NewPtrInfo(OldMMO->getPointerInfo());
 185     if (const PseudoSourceValue *PSV =
 186             dyn_cast_if_present<const PseudoSourceValue *>(NewPtrInfo.V)) {
 187       switch (PSV->kind()) {
 188       case PseudoSourceValue::Stack:
 189         NewPtrInfo.V = PSVMgr.getStack();
 190         break;
 191       case PseudoSourceValue::GOT:
 192         NewPtrInfo.V = PSVMgr.getGOT();
 193         break;
 194       case PseudoSourceValue::JumpTable:
 195         NewPtrInfo.V = PSVMgr.getJumpTable();
 196         break;
 197       case PseudoSourceValue::ConstantPool:
 198         NewPtrInfo.V = PSVMgr.getConstantPool();
 199         break;
 200       case PseudoSourceValue::FixedStack:
 201         NewPtrInfo.V = PSVMgr.getFixedStack(
 202             cast<FixedStackPseudoSourceValue>(PSV)->getFrameIndex());
 203         break;
 204       case PseudoSourceValue::GlobalValueCallEntry:
 205         NewPtrInfo.V = PSVMgr.getGlobalValueCallEntry(
 206             cast<GlobalValuePseudoSourceValue>(PSV)->getValue());
 207         break;
 208       case PseudoSourceValue::ExternalSymbolCallEntry:
 209         NewPtrInfo.V = PSVMgr.getExternalSymbolCallEntry(
 210             cast<ExternalSymbolPseudoSourceValue>(PSV)->getSymbol());
 211         break;
 212       case PseudoSourceValue::TargetCustom:
 213       default:
 214         // FIXME: We have no generic interface for allocating custom PSVs.
 215         report_fatal_error("Cloning TargetCustom PSV not handled");
 216       }
 217     }
 218
 219     MachineMemOperand *NewMMO = DstMF.getMachineMemOperand(
 220         NewPtrInfo, OldMMO->getFlags(), OldMMO->getMemoryType(),
 221         OldMMO->getBaseAlign(), OldMMO->getAAInfo(), OldMMO->getRanges(),
 222         OldMMO->getSyncScopeID(), OldMMO->getSuccessOrdering(),
 223         OldMMO->getFailureOrdering());
 224     NewMMOs.push_back(NewMMO);
 225   }
 226
 227   DstMI.setMemRefs(DstMF, NewMMOs);
 228 }
 229
 230 static std::unique_ptr<MachineFunction> cloneMF(MachineFunction *SrcMF,
 231                                                 MachineModuleInfo &DestMMI) {
 232   auto DstMF = std::make_unique<MachineFunction>(
 233       SrcMF->getFunction(), SrcMF->getTarget(), SrcMF->getSubtarget(),
 234       SrcMF->getFunctionNumber(), DestMMI);
 235   DenseMap<MachineBasicBlock *, MachineBasicBlock *> Src2DstMBB;
 236
 237   auto *SrcMRI = &SrcMF->getRegInfo();
 238   auto *DstMRI = &DstMF->getRegInfo();
 239
 240   // Clone blocks.
 241   for (MachineBasicBlock &SrcMBB : *SrcMF) {
 242     MachineBasicBlock *DstMBB =
 243         DstMF->CreateMachineBasicBlock(SrcMBB.getBasicBlock());
 244     Src2DstMBB[&SrcMBB] = DstMBB;
 245
 246     DstMBB->setCallFrameSize(SrcMBB.getCallFrameSize());
 247
 248     if (SrcMBB.isIRBlockAddressTaken())
 249       DstMBB->setAddressTakenIRBlock(SrcMBB.getAddressTakenIRBlock());
 250     if (SrcMBB.isMachineBlockAddressTaken())
 251       DstMBB->setMachineBlockAddressTaken();
 252
 253     // FIXME: This is not serialized
 254     if (SrcMBB.hasLabelMustBeEmitted())
 255       DstMBB->setLabelMustBeEmitted();
 256
 257     DstMBB->setAlignment(SrcMBB.getAlignment());
 258
 259     // FIXME: This is not serialized
 260     DstMBB->setMaxBytesForAlignment(SrcMBB.getMaxBytesForAlignment());
 261
 262     DstMBB->setIsEHPad(SrcMBB.isEHPad());
 263     DstMBB->setIsEHScopeEntry(SrcMBB.isEHScopeEntry());
 264     DstMBB->setIsEHCatchretTarget(SrcMBB.isEHCatchretTarget());
 265     DstMBB->setIsEHFuncletEntry(SrcMBB.isEHFuncletEntry());
 266
 267     // FIXME: These are not serialized
 268     DstMBB->setIsCleanupFuncletEntry(SrcMBB.isCleanupFuncletEntry());
 269     DstMBB->setIsBeginSection(SrcMBB.isBeginSection());
 270     DstMBB->setIsEndSection(SrcMBB.isEndSection());
 271
 272     DstMBB->setSectionID(SrcMBB.getSectionID());
 273     DstMBB->setIsInlineAsmBrIndirectTarget(
 274         SrcMBB.isInlineAsmBrIndirectTarget());
 275
 276     // FIXME: This is not serialized
 277     if (std::optional<uint64_t> Weight = SrcMBB.getIrrLoopHeaderWeight())
 278       DstMBB->setIrrLoopHeaderWeight(*Weight);
 279   }
 280
 281   const MachineFrameInfo &SrcMFI = SrcMF->getFrameInfo();
 282   MachineFrameInfo &DstMFI = DstMF->getFrameInfo();
 283
 284   // Copy stack objects and other info
 285   cloneFrameInfo(DstMFI, SrcMFI, Src2DstMBB);
 286
 287   if (MachineJumpTableInfo *SrcJTI = SrcMF->getJumpTableInfo()) {
 288     cloneJumpTableInfo(*DstMF, *SrcJTI, Src2DstMBB);
 289   }
 290
 291   // Remap the debug info frame index references.
 292   DstMF->VariableDbgInfos = SrcMF->VariableDbgInfos;
 293
 294   // Clone virtual registers
 295   for (unsigned I = 0, E = SrcMRI->getNumVirtRegs(); I != E; ++I) {
 296     Register Reg = Register::index2VirtReg(I);
 297     Register NewReg = DstMRI->createIncompleteVirtualRegister(
 298       SrcMRI->getVRegName(Reg));
 299     assert(NewReg == Reg && "expected to preserve virtreg number");
 300
 301     DstMRI->setRegClassOrRegBank(NewReg, SrcMRI->getRegClassOrRegBank(Reg));
 302
 303     LLT RegTy = SrcMRI->getType(Reg);
 304     if (RegTy.isValid())
 305       DstMRI->setType(NewReg, RegTy);
 306
 307     // Copy register allocation hints.
 308     const auto &Hints = SrcMRI->getRegAllocationHints(Reg);
 309     for (Register PrefReg : Hints.second)
 310       DstMRI->addRegAllocationHint(NewReg, PrefReg);
 311   }
 312
 313   const TargetSubtargetInfo &STI = DstMF->getSubtarget();
 314   const TargetInstrInfo *TII = STI.getInstrInfo();
 315   const TargetRegisterInfo *TRI = STI.getRegisterInfo();
 316
 317   // Link blocks.
 318   for (auto &SrcMBB : *SrcMF) {
 319     auto *DstMBB = Src2DstMBB[&SrcMBB];
 320     DstMF->push_back(DstMBB);
 321
 322     for (auto It = SrcMBB.succ_begin(), IterEnd = SrcMBB.succ_end();
 323          It != IterEnd; ++It) {
 324       auto *SrcSuccMBB = *It;
 325       auto *DstSuccMBB = Src2DstMBB[SrcSuccMBB];
 326       DstMBB->addSuccessor(DstSuccMBB, SrcMBB.getSuccProbability(It));
 327     }
 328
 329     for (auto &LI : SrcMBB.liveins_dbg())
 330       DstMBB->addLiveIn(LI);
 331
 332     // Make sure MRI knows about registers clobbered by unwinder.
 333     if (DstMBB->isEHPad()) {
 334       if (auto *RegMask = TRI->getCustomEHPadPreservedMask(*DstMF))
 335         DstMRI->addPhysRegsUsedFromRegMask(RegMask);
 336     }
 337   }
 338
 339   DenseSet<const uint32_t *> ConstRegisterMasks;
 340
 341   // Track predefined/named regmasks which we ignore.
 342   for (const uint32_t *Mask : TRI->getRegMasks())
 343     ConstRegisterMasks.insert(Mask);
 344
 345   // Clone instructions.
 346   for (auto &SrcMBB : *SrcMF) {
 347     auto *DstMBB = Src2DstMBB[&SrcMBB];
 348     for (auto &SrcMI : SrcMBB) {
 349       const auto &MCID = TII->get(SrcMI.getOpcode());
 350       auto *DstMI = DstMF->CreateMachineInstr(MCID, SrcMI.getDebugLoc(),
 351                                               /*NoImplicit=*/true);
 352       DstMI->setFlags(SrcMI.getFlags());
 353       DstMI->setAsmPrinterFlag(SrcMI.getAsmPrinterFlags());
 354
 355       DstMBB->push_back(DstMI);
 356       for (auto &SrcMO : SrcMI.operands()) {
 357         MachineOperand DstMO(SrcMO);
 358         DstMO.clearParent();
 359
 360         // Update MBB.
 361         if (DstMO.isMBB())
 362           DstMO.setMBB(Src2DstMBB[DstMO.getMBB()]);
 363         else if (DstMO.isRegMask()) {
 364           DstMRI->addPhysRegsUsedFromRegMask(DstMO.getRegMask());
 365
 366           if (!ConstRegisterMasks.count(DstMO.getRegMask())) {
 367             uint32_t *DstMask = DstMF->allocateRegMask();
 368             std::memcpy(DstMask, SrcMO.getRegMask(),
 369                         sizeof(*DstMask) *
 370                             MachineOperand::getRegMaskSize(TRI->getNumRegs()));
 371             DstMO.setRegMask(DstMask);
 372           }
 373         }
 374
 375         DstMI->addOperand(DstMO);
 376       }
 377
 378       cloneMemOperands(*DstMI, SrcMI, *SrcMF, *DstMF);
 379     }
 380   }
 381
 382   DstMF->setAlignment(SrcMF->getAlignment());
 383   DstMF->setExposesReturnsTwice(SrcMF->exposesReturnsTwice());
 384   DstMF->setHasInlineAsm(SrcMF->hasInlineAsm());
 385   DstMF->setHasWinCFI(SrcMF->hasWinCFI());
 386
 387   DstMF->getProperties().reset().set(SrcMF->getProperties());
 388
 389   if (!SrcMF->getFrameInstructions().empty() ||
 390       !SrcMF->getLongjmpTargets().empty() ||
 391       !SrcMF->getCatchretTargets().empty())
 392     report_fatal_error("cloning not implemented for machine function property");
 393
 394   DstMF->setCallsEHReturn(SrcMF->callsEHReturn());
 395   DstMF->setCallsUnwindInit(SrcMF->callsUnwindInit());
 396   DstMF->setHasEHCatchret(SrcMF->hasEHCatchret());
 397   DstMF->setHasEHScopes(SrcMF->hasEHScopes());
 398   DstMF->setHasEHFunclets(SrcMF->hasEHFunclets());
 399   DstMF->setIsOutlined(SrcMF->isOutlined());
 400
 401   if (!SrcMF->getLandingPads().empty() ||
 402       !SrcMF->getCodeViewAnnotations().empty() ||
 403       !SrcMF->getTypeInfos().empty() ||
 404       !SrcMF->getFilterIds().empty() ||
 405       SrcMF->hasAnyWasmLandingPadIndex() ||
 406       SrcMF->hasAnyCallSiteLandingPad() ||
 407       SrcMF->hasAnyCallSiteLabel() ||
 408       !SrcMF->getCallSitesInfo().empty())
 409     report_fatal_error("cloning not implemented for machine function property");
 410
 411   DstMF->setDebugInstrNumberingCount(SrcMF->DebugInstrNumberingCount);
 412
 413   if (!DstMF->cloneInfoFrom(*SrcMF, Src2DstMBB))
 414     report_fatal_error("target does not implement MachineFunctionInfo cloning");
 415
 416   DstMRI->freezeReservedRegs(*DstMF);
 417
 418   DstMF->verify(nullptr, "", /*AbortOnError=*/true);
 419   return DstMF;
 420 }
 421
 422 static void initializeTargetInfo() {
 423   InitializeAllTargets();
 424   InitializeAllTargetMCs();
 425   InitializeAllAsmPrinters();
 426   InitializeAllAsmParsers();
 427 }
 428
 429 void ReducerWorkItem::print(raw_ostream &ROS, void *p) const {
 430   if (MMI) {
 431     printMIR(ROS, *M);
 432     for (Function &F : *M) {
 433       if (auto *MF = MMI->getMachineFunction(F))
 434         printMIR(ROS, *MF);
 435     }
 436   } else {
 437     M->print(ROS, /*AssemblyAnnotationWriter=*/nullptr,
 438              /*ShouldPreserveUseListOrder=*/true);
 439   }
 440 }
 441
 442 bool ReducerWorkItem::verify(raw_fd_ostream *OS) const {
 443   if (verifyModule(*M, OS))
 444     return true;
 445
 446   if (!MMI)
 447     return false;
 448
 449   for (const Function &F : getModule()) {
 450     if (const MachineFunction *MF = MMI->getMachineFunction(F)) {
 451       if (!MF->verify(nullptr, "", /*AbortOnError=*/false))
 452         return true;
 453     }
 454   }
 455
 456   return false;
 457 }
 458
 459 bool ReducerWorkItem::isReduced(const TestRunner &Test) const {
 460   const bool UseBitcode = Test.inputIsBitcode() || TmpFilesAsBitcode;
 461
 462   SmallString<128> CurrentFilepath;
 463
 464   // Write ReducerWorkItem to tmp file
 465   int FD;
 466   std::error_code EC = sys::fs::createTemporaryFile(
 467       "llvm-reduce", isMIR() ? "mir" : (UseBitcode ? "bc" : "ll"), FD,
 468       CurrentFilepath,
 469       UseBitcode && !isMIR() ? sys::fs::OF_None : sys::fs::OF_Text);
 470   if (EC) {
 471     WithColor::error(errs(), Test.getToolName())
 472         << "error making unique filename: " << EC.message() << '\n';
 473     exit(1);
 474   }
 475
 476   ToolOutputFile Out(CurrentFilepath, FD);
 477
 478   writeOutput(Out.os(), UseBitcode);
 479
 480   Out.os().close();
 481   if (Out.os().has_error()) {
 482     WithColor::error(errs(), Test.getToolName())
 483         << "error emitting bitcode to file '" << CurrentFilepath
 484         << "': " << Out.os().error().message() << '\n';
 485     exit(1);
 486   }
 487
 488   // Current Chunks aren't interesting
 489   return Test.run(CurrentFilepath);
 490 }
 491
 492 std::unique_ptr<ReducerWorkItem>
 493 ReducerWorkItem::clone(const TargetMachine *TM) const {
 494   auto CloneMMM = std::make_unique<ReducerWorkItem>();
 495   if (TM) {
 496     // We're assuming the Module IR contents are always unchanged by MIR
 497     // reductions, and can share it as a constant.
 498     CloneMMM->M = M;
 499
 500     // MachineModuleInfo contains a lot of other state used during codegen which
 501     // we won't be using here, but we should be able to ignore it (although this
 502     // is pretty ugly).
 503     const LLVMTargetMachine *LLVMTM =
 504         static_cast<const LLVMTargetMachine *>(TM);
 505     CloneMMM->MMI = std::make_unique<MachineModuleInfo>(LLVMTM);
 506
 507     for (const Function &F : getModule()) {
 508       if (auto *MF = MMI->getMachineFunction(F))
 509         CloneMMM->MMI->insertFunction(F, cloneMF(MF, *CloneMMM->MMI));
 510     }
 511   } else {
 512     CloneMMM->M = CloneModule(*M);
 513   }
 514   return CloneMMM;
 515 }
 516
 517 /// Try to produce some number that indicates a function is getting smaller /
 518 /// simpler.
 519 static uint64_t computeMIRComplexityScoreImpl(const MachineFunction &MF) {
 520   uint64_t Score = 0;
 521   const MachineFrameInfo &MFI = MF.getFrameInfo();
 522
 523   // Add for stack objects
 524   Score += MFI.getNumObjects();
 525
 526   // Add in the block count.
 527   Score += 2 * MF.size();
 528
 529   const MachineRegisterInfo &MRI = MF.getRegInfo();
 530   for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
 531     Register Reg = Register::index2VirtReg(I);
 532     Score += MRI.getRegAllocationHints(Reg).second.size();
 533   }
 534
 535   for (const MachineBasicBlock &MBB : MF) {
 536     for (const MachineInstr &MI : MBB) {
 537       const unsigned Opc = MI.getOpcode();
 538
 539       // Reductions may want or need to introduce implicit_defs, so don't count
 540       // them.
 541       // TODO: These probably should count in some way.
 542       if (Opc == TargetOpcode::IMPLICIT_DEF ||
 543           Opc == TargetOpcode::G_IMPLICIT_DEF)
 544         continue;
 545
 546       // Each instruction adds to the score
 547       Score += 4;
 548
 549       if (Opc == TargetOpcode::PHI || Opc == TargetOpcode::G_PHI ||
 550           Opc == TargetOpcode::INLINEASM || Opc == TargetOpcode::INLINEASM_BR)
 551         ++Score;
 552
 553       if (MI.getFlags() != 0)
 554         ++Score;
 555
 556       // Increase weight for more operands.
 557       for (const MachineOperand &MO : MI.operands()) {
 558         ++Score;
 559
 560         // Treat registers as more complex.
 561         if (MO.isReg()) {
 562           ++Score;
 563
 564           // And subregisters as even more complex.
 565           if (MO.getSubReg()) {
 566             ++Score;
 567             if (MO.isDef())
 568               ++Score;
 569           }
 570         } else if (MO.isRegMask())
 571           ++Score;
 572       }
 573     }
 574   }
 575
 576   return Score;
 577 }
 578
 579 uint64_t ReducerWorkItem::computeMIRComplexityScore() const {
 580   uint64_t Score = 0;
 581
 582   for (const Function &F : getModule()) {
 583     if (auto *MF = MMI->getMachineFunction(F))
 584       Score += computeMIRComplexityScoreImpl(*MF);
 585   }
 586
 587   return Score;
 588 }
 589
 590 // FIXME: ReduceOperandsSkip has similar function, except it uses larger numbers
 591 // for more reduced.
 592 static unsigned classifyReductivePower(const Value *V) {
 593   if (auto *C = dyn_cast<ConstantData>(V)) {
 594     if (C->isNullValue())
 595       return 0;
 596     if (C->isOneValue())
 597       return 1;
 598     if (isa<UndefValue>(V))
 599       return 2;
 600     return 3;
 601   }
 602
 603   if (isa<GlobalValue>(V))
 604     return 4;
 605
 606   // TODO: Account for expression size
 607   if (isa<ConstantExpr>(V))
 608     return 5;
 609
 610   if (isa<Constant>(V))
 611     return 1;
 612
 613   if (isa<Argument>(V))
 614     return 6;
 615
 616   if (isa<Instruction>(V))
 617     return 7;
 618
 619   return 0;
 620 }
 621
 622 // TODO: Additional flags and attributes may be complexity reducing. If we start
 623 // adding flags and attributes, they could have negative cost.
 624 static uint64_t computeIRComplexityScoreImpl(const Function &F) {
 625   uint64_t Score = 1; // Count the function itself
 626   SmallVector<std::pair<unsigned, MDNode *>> MDs;
 627
 628   AttributeList Attrs = F.getAttributes();
 629   for (AttributeSet AttrSet : Attrs)
 630     Score += AttrSet.getNumAttributes();
 631
 632   for (const BasicBlock &BB : F) {
 633     ++Score;
 634
 635     for (const Instruction &I : BB) {
 636       ++Score;
 637
 638       if (const auto *OverflowOp = dyn_cast<OverflowingBinaryOperator>(&I)) {
 639         if (OverflowOp->hasNoUnsignedWrap())
 640           ++Score;
 641         if (OverflowOp->hasNoSignedWrap())
 642           ++Score;
 643       } else if (const auto *GEP = dyn_cast<GEPOperator>(&I)) {
 644         if (GEP->isInBounds())
 645           ++Score;
 646       } else if (const auto *ExactOp = dyn_cast<PossiblyExactOperator>(&I)) {
 647         if (ExactOp->isExact())
 648           ++Score;
 649       } else if (const auto *FPOp = dyn_cast<FPMathOperator>(&I)) {
 650         FastMathFlags FMF = FPOp->getFastMathFlags();
 651         if (FMF.allowReassoc())
 652           ++Score;
 653         if (FMF.noNaNs())
 654           ++Score;
 655         if (FMF.noInfs())
 656           ++Score;
 657         if (FMF.noSignedZeros())
 658           ++Score;
 659         if (FMF.allowReciprocal())
 660           ++Score;
 661         if (FMF.allowContract())
 662           ++Score;
 663         if (FMF.approxFunc())
 664           ++Score;
 665       }
 666
 667       for (const Value *Operand : I.operands()) {
 668         ++Score;
 669         Score += classifyReductivePower(Operand);
 670       }
 671
 672       I.getAllMetadata(MDs);
 673       Score += MDs.size();
 674       MDs.clear();
 675     }
 676   }
 677
 678   return Score;
 679 }
 680
 681 uint64_t ReducerWorkItem::computeIRComplexityScore() const {
 682   uint64_t Score = 0;
 683
 684   const Module &M = getModule();
 685   Score += M.named_metadata_size();
 686
 687   SmallVector<std::pair<unsigned, MDNode *>, 32> GlobalMetadata;
 688   for (const GlobalVariable &GV : M.globals()) {
 689     ++Score;
 690
 691     if (GV.hasInitializer())
 692       Score += classifyReductivePower(GV.getInitializer());
 693
 694     // TODO: Account for linkage?
 695
 696     GV.getAllMetadata(GlobalMetadata);
 697     Score += GlobalMetadata.size();
 698     GlobalMetadata.clear();
 699   }
 700
 701   for (const GlobalAlias &GA : M.aliases())
 702     Score += classifyReductivePower(GA.getAliasee());
 703
 704   for (const GlobalIFunc &GI : M.ifuncs())
 705     Score += classifyReductivePower(GI.getResolver());
 706
 707   for (const Function &F : M)
 708     Score += computeIRComplexityScoreImpl(F);
 709
 710   return Score;
 711 }
 712
 713 void ReducerWorkItem::writeOutput(raw_ostream &OS, bool EmitBitcode) const {
 714   // Requesting bitcode emission with mir is nonsense, so just ignore it.
 715   if (EmitBitcode && !isMIR())
 716     writeBitcode(OS);
 717   else
 718     print(OS, /*AnnotationWriter=*/nullptr);
 719 }
 720
 721 void ReducerWorkItem::readBitcode(MemoryBufferRef Data, LLVMContext &Ctx,
 722                                   StringRef ToolName) {
 723   Expected<BitcodeFileContents> IF = llvm::getBitcodeFileContents(Data);
 724   if (!IF) {
 725     WithColor::error(errs(), ToolName) << IF.takeError();
 726     exit(1);
 727   }
 728   BitcodeModule BM = IF->Mods[0];
 729   Expected<BitcodeLTOInfo> LI = BM.getLTOInfo();
 730   Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(Ctx);
 731   if (!LI || !MOrErr) {
 732     WithColor::error(errs(), ToolName) << IF.takeError();
 733     exit(1);
 734   }
 735   LTOInfo = std::make_unique<BitcodeLTOInfo>(*LI);
 736   M = std::move(MOrErr.get());
 737 }
 738
 739 void ReducerWorkItem::writeBitcode(raw_ostream &OutStream) const {
 740   if (LTOInfo && LTOInfo->IsThinLTO && LTOInfo->EnableSplitLTOUnit) {
 741     PassBuilder PB;
 742     LoopAnalysisManager LAM;
 743     FunctionAnalysisManager FAM;
 744     CGSCCAnalysisManager CGAM;
 745     ModuleAnalysisManager MAM;
 746     PB.registerModuleAnalyses(MAM);
 747     PB.registerCGSCCAnalyses(CGAM);
 748     PB.registerFunctionAnalyses(FAM);
 749     PB.registerLoopAnalyses(LAM);
 750     PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 751     ModulePassManager MPM;
 752     MPM.addPass(ThinLTOBitcodeWriterPass(OutStream, nullptr));
 753     MPM.run(*M, MAM);
 754   } else {
 755     std::unique_ptr<ModuleSummaryIndex> Index;
 756     if (LTOInfo && LTOInfo->HasSummary) {
 757       ProfileSummaryInfo PSI(*M);
 758       Index = std::make_unique<ModuleSummaryIndex>(
 759           buildModuleSummaryIndex(*M, nullptr, &PSI));
 760     }
 761     WriteBitcodeToFile(getModule(), OutStream,
 762                        /*ShouldPreserveUseListOrder=*/true, Index.get());
 763   }
 764 }
 765
 766 std::pair<std::unique_ptr<ReducerWorkItem>, bool>
 767 llvm::parseReducerWorkItem(StringRef ToolName, StringRef Filename,
 768                            LLVMContext &Ctxt,
 769                            std::unique_ptr<TargetMachine> &TM, bool IsMIR) {
 770   bool IsBitcode = false;
 771   Triple TheTriple;
 772
 773   auto MMM = std::make_unique<ReducerWorkItem>();
 774
 775   if (IsMIR) {
 776     initializeTargetInfo();
 777
 778     auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
 779     if (std::error_code EC = FileOrErr.getError()) {
 780       WithColor::error(errs(), ToolName) << EC.message() << '\n';
 781       return {nullptr, false};
 782     }
 783
 784     std::unique_ptr<MIRParser> MParser =
 785         createMIRParser(std::move(FileOrErr.get()), Ctxt);
 786
 787     auto SetDataLayout = [&](StringRef DataLayoutTargetTriple,
 788                              StringRef OldDLStr) -> std::optional<std::string> {
 789       // NB: We always call createTargetMachineForTriple() even if an explicit
 790       // DataLayout is already set in the module since we want to use this
 791       // callback to setup the TargetMachine rather than doing it later.
 792       std::string IRTargetTriple = DataLayoutTargetTriple.str();
 793       if (!TargetTriple.empty())
 794         IRTargetTriple = Triple::normalize(TargetTriple);
 795       TheTriple = Triple(IRTargetTriple);
 796       if (TheTriple.getTriple().empty())
 797         TheTriple.setTriple(sys::getDefaultTargetTriple());
 798       ExitOnError ExitOnErr(std::string(ToolName) + ": error: ");
 799       TM = ExitOnErr(codegen::createTargetMachineForTriple(TheTriple.str()));
 800
 801       return TM->createDataLayout().getStringRepresentation();
 802     };
 803
 804     std::unique_ptr<Module> M = MParser->parseIRModule(SetDataLayout);
 805     LLVMTargetMachine *LLVMTM = static_cast<LLVMTargetMachine *>(TM.get());
 806
 807     MMM->MMI = std::make_unique<MachineModuleInfo>(LLVMTM);
 808     MParser->parseMachineFunctions(*M, *MMM->MMI);
 809     MMM->M = std::move(M);
 810   } else {
 811     SMDiagnostic Err;
 812     ErrorOr<std::unique_ptr<MemoryBuffer>> MB =
 813         MemoryBuffer::getFileOrSTDIN(Filename);
 814     if (std::error_code EC = MB.getError()) {
 815       WithColor::error(errs(), ToolName)
 816           << Filename << ": " << EC.message() << "\n";
 817       return {nullptr, false};
 818     }
 819
 820     if (!isBitcode((const unsigned char *)(*MB)->getBufferStart(),
 821                    (const unsigned char *)(*MB)->getBufferEnd())) {
 822       std::unique_ptr<Module> Result = parseIR(**MB, Err, Ctxt);
 823       if (!Result) {
 824         Err.print(ToolName.data(), errs());
 825         return {nullptr, false};
 826       }
 827       MMM->M = std::move(Result);
 828     } else {
 829       IsBitcode = true;
 830       MMM->readBitcode(MemoryBufferRef(**MB), Ctxt, ToolName);
 831
 832       if (MMM->LTOInfo->IsThinLTO && MMM->LTOInfo->EnableSplitLTOUnit)
 833         initializeTargetInfo();
 834     }
 835   }
 836   if (MMM->verify(&errs())) {
 837     WithColor::error(errs(), ToolName)
 838         << Filename << " - input module is broken!\n";
 839     return {nullptr, false};
 840   }
 841   return {std::move(MMM), IsBitcode};
 842 }