|
| 1 | +//===- FatLtoCleanup.cpp - clean up IR for the FatLTO pipeline --*- C++ -*-===// |
| 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 | +// This file defines operations used to clean up IR for the FatLTO pipeline. |
| 10 | +// Instrumentation that is beneficial for bitcode sections used in LTO may |
| 11 | +// need to be cleaned up to finish non-LTO compilation. llvm.checked.load is |
| 12 | +// and example of an instruction that we want to preserve for LTO, but is |
| 13 | +// incorrect to leave unchanged during the per-TU compilation in FatLTO. |
| 14 | +// |
| 15 | +//===----------------------------------------------------------------------===// |
| 16 | + |
| 17 | +#include "llvm/Transforms/IPO/FatLTOCleanup.h" |
| 18 | +#include "llvm/ADT/SetVector.h" |
| 19 | +#include "llvm/IR/Function.h" |
| 20 | +#include "llvm/IR/IRBuilder.h" |
| 21 | +#include "llvm/IR/Intrinsics.h" |
| 22 | +#include "llvm/IR/Module.h" |
| 23 | +#include "llvm/IR/PassManager.h" |
| 24 | +#include "llvm/IR/Use.h" |
| 25 | +#include "llvm/Support/Debug.h" |
| 26 | + |
| 27 | +using namespace llvm; |
| 28 | + |
| 29 | +#define DEBUG_TYPE "fatlto-cleanup" |
| 30 | + |
| 31 | +namespace { |
| 32 | +// Replaces uses of llvm.type.checked.load instructions with unchecked loads. |
| 33 | +// In essence, we're undoing the frontends instrumentation, since it isn't |
| 34 | +// correct for the non-LTO part of a FatLTO object. |
| 35 | +// |
| 36 | +// llvm.type.checked.load instruction sequences always have a particular form: |
| 37 | +// |
| 38 | +// clang-format off |
| 39 | +// |
| 40 | +// %0 = tail call { ptr, i1 } @llvm.type.checked.load(ptr %vtable, i32 0, metadata !"foo"), !nosanitize !0 |
| 41 | +// %1 = extractvalue { ptr, i1 } %0, 1, !nosanitize !0 |
| 42 | +// br i1 %1, label %cont2, label %trap1, !nosanitize !0 |
| 43 | +// |
| 44 | +// trap1: ; preds = %entry |
| 45 | +// tail call void @llvm.ubsantrap(i8 2) #3, !nosanitize !0 |
| 46 | +// unreachable, !nosanitize !0 |
| 47 | +// |
| 48 | +// cont2: ; preds = %entry |
| 49 | +// %2 = extractvalue { ptr, i1 } %0, 0, !nosanitize !0 |
| 50 | +// %call = tail call noundef i64 %2(ptr noundef nonnull align 8 dereferenceable(8) %p1) #4 |
| 51 | +// |
| 52 | +// clang-format on |
| 53 | +// |
| 54 | +// In this sequence, the vtable pointer is first loaded and checked against some |
| 55 | +// metadata. The result indicates failure, then the program traps. On the |
| 56 | +// success path, the pointer is used to make an indirect call to the function |
| 57 | +// pointer loaded from the vtable. |
| 58 | +// |
| 59 | +// Since we won't be able to lower this correctly later in non-LTO builds, we |
| 60 | +// need to drop the special load and trap, and emit a normal load of the |
| 61 | +// function pointer from the vtable. |
| 62 | +// |
| 63 | +// This is straight forward, since the checked load can be replaced w/ a load |
| 64 | +// of the vtable pointer and a GEP instruction to index into the vtable and get |
| 65 | +// the correct method/function pointer. We replace the "check" with a constant |
| 66 | +// indicating success, which allows later passes to simplify control flow and |
| 67 | +// remove any now dead instructions. |
| 68 | +// |
| 69 | +// This logic holds for both llvm.type.checked.load and |
| 70 | +// llvm.type.checked.load.relative instructions. |
| 71 | +static bool cleanUpTypeCheckedLoad(Module &M, Function &CheckedLoadFn) { |
| 72 | + bool Changed = false; |
| 73 | + // Use SetVector so we can rely on insertion order to drop instructions |
| 74 | + // in a safe order (e.g. uses before defs), and avoid adding instructions |
| 75 | + // to the drop set multiple times. |
| 76 | + SetVector<Instruction *> ToDrop; |
| 77 | + for (Use &U : llvm::make_early_inc_range(CheckedLoadFn.uses())) { |
| 78 | + for (auto *User : U->users()) { |
| 79 | + Instruction *I = dyn_cast<Instruction>(User); |
| 80 | + if (!I) |
| 81 | + continue; |
| 82 | + LLVM_DEBUG(dbgs() << "Checking candidate instruction" << *I << "\n"); |
| 83 | + |
| 84 | + IRBuilder<> IRB(I); |
| 85 | + Value *Ptr = I->getOperand(0); |
| 86 | + Value *Offset = I->getOperand(1); |
| 87 | + Type *Ty = I->getType()->getContainedType(0); |
| 88 | + // Use i8 so we can directly use the offset from llvm.type.checked.load. |
| 89 | + Value *Gep = IRB.CreateGEP(Type::getInt8Ty(M.getContext()), Ptr, Offset); |
| 90 | + LoadInst *L = IRB.CreateLoad(Ty, Gep, "vfunc"); |
| 91 | + |
| 92 | + bool Replaced = false; |
| 93 | + for (auto *MaybeEv : I->users()) { |
| 94 | + auto *EV = dyn_cast<ExtractValueInst>(MaybeEv); |
| 95 | + if (!EV) |
| 96 | + continue; |
| 97 | + |
| 98 | + size_t Index = EV->getIndices()[0]; |
| 99 | + if (Index == 0) { |
| 100 | + // If EV is extracting a vtable ptr, replace it w/ a direct load. |
| 101 | + LLVM_DEBUG(llvm::dbgs() |
| 102 | + << "Replacing " << *EV << " with " << *L << "\n"); |
| 103 | + EV->replaceAllUsesWith(L); |
| 104 | + ToDrop.insert(EV); |
| 105 | + LLVM_DEBUG(dbgs() |
| 106 | + << DEBUG_TYPE << ": add " << *EV << "to drop set.\n"); |
| 107 | + Replaced = true; |
| 108 | + } else if (Index == 1) { |
| 109 | + // If EV is extracting the boolean, replace it w/ a constant, so |
| 110 | + // that the branch to trap will be dropped later. |
| 111 | + ConstantInt *C = ConstantInt::getTrue(M.getContext()); |
| 112 | + LLVM_DEBUG(llvm::dbgs() << DEBUG_TYPE << ": replacing " << *EV |
| 113 | + << " with " << *C << "\n"); |
| 114 | + EV->replaceAllUsesWith(C); |
| 115 | + ToDrop.insert(EV); |
| 116 | + LLVM_DEBUG(dbgs() |
| 117 | + << DEBUG_TYPE << ": add " << *EV << "to drop set.\n"); |
| 118 | + Replaced = true; |
| 119 | + } |
| 120 | + } |
| 121 | + if (Replaced) { |
| 122 | + LLVM_DEBUG(dbgs() << DEBUG_TYPE << ": add " << *I << "to drop set.\n"); |
| 123 | + ToDrop.insert(I); |
| 124 | + Changed = true; |
| 125 | + } |
| 126 | + } |
| 127 | + } |
| 128 | + for (Instruction *I : ToDrop) { |
| 129 | + LLVM_DEBUG(dbgs() << "Dropping instruction:" << *I << "\n"); |
| 130 | + I->eraseFromParent(); |
| 131 | + } |
| 132 | + if (Changed) |
| 133 | + CheckedLoadFn.eraseFromParent(); |
| 134 | + return Changed; |
| 135 | +} |
| 136 | +} // namespace |
| 137 | + |
| 138 | +PreservedAnalyses FatLtoCleanup::run(Module &M, ModuleAnalysisManager &AM) { |
| 139 | + Function *TypeCheckedLoadFn = |
| 140 | + Intrinsic::getDeclarationIfExists(&M, Intrinsic::type_checked_load); |
| 141 | + Function *TypeCheckedLoadRelFn = Intrinsic::getDeclarationIfExists( |
| 142 | + &M, Intrinsic::type_checked_load_relative); |
| 143 | + |
| 144 | + bool Changed = false; |
| 145 | + if (TypeCheckedLoadFn) |
| 146 | + Changed |= cleanUpTypeCheckedLoad(M, *TypeCheckedLoadFn); |
| 147 | + if (TypeCheckedLoadRelFn) |
| 148 | + Changed |= cleanUpTypeCheckedLoad(M, *TypeCheckedLoadRelFn); |
| 149 | + |
| 150 | + if (Changed) { |
| 151 | + // M.dump(); |
| 152 | + return PreservedAnalyses::none(); |
| 153 | + } |
| 154 | + |
| 155 | + return PreservedAnalyses::all(); |
| 156 | +} |
0 commit comments