1//===-- WebAssemblyFixFunctionBitcasts.cpp - Fix function bitcasts --------===//
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/// \file
10/// Fix bitcasted functions.
11///
12/// WebAssembly requires caller and callee signatures to match, however in LLVM,
13/// some amount of slop is vaguely permitted. Detect mismatch by looking for
14/// bitcasts of functions and rewrite them to use wrapper functions instead.
15///
16/// This doesn't catch all cases, such as when a function's address is taken in
17/// one place and casted in another, but it works for many common cases.
18///
19/// Note that LLVM already optimizes away function bitcasts in common cases by
20/// dropping arguments as needed, so this pass only ends up getting used in less
21/// common cases.
22///
23//===----------------------------------------------------------------------===//
24
25#include "WebAssembly.h"
26#include "llvm/IR/Constants.h"
27#include "llvm/IR/Instructions.h"
28#include "llvm/IR/Module.h"
29#include "llvm/IR/Operator.h"
30#include "llvm/Pass.h"
31#include "llvm/Support/Debug.h"
32#include "llvm/Support/raw_ostream.h"
33using namespace llvm;
34
35#define DEBUG_TYPE "wasm-fix-function-bitcasts"
36
37namespace {
38class FixFunctionBitcasts final : public ModulePass {
39  StringRef getPassName() const override {
40    return "WebAssembly Fix Function Bitcasts";
41  }
42
43  void getAnalysisUsage(AnalysisUsage &AU) const override {
44    AU.setPreservesCFG();
45    ModulePass::getAnalysisUsage(AU);
46  }
47
48  bool runOnModule(Module &M) override;
49
50public:
51  static char ID;
52  FixFunctionBitcasts() : ModulePass(ID) {}
53};
54} // End anonymous namespace
55
56char FixFunctionBitcasts::ID = 0;
57INITIALIZE_PASS(FixFunctionBitcasts, DEBUG_TYPE,
58                "Fix mismatching bitcasts for WebAssembly", false, false)
59
60ModulePass *llvm::createWebAssemblyFixFunctionBitcasts() {
61  return new FixFunctionBitcasts();
62}
63
64// Recursively descend the def-use lists from V to find non-bitcast users of
65// bitcasts of V.
66static void findUses(Value *V, Function &F,
67                     SmallVectorImpl<std::pair<CallBase *, Function *>> &Uses) {
68  for (User *U : V->users()) {
69    if (auto *BC = dyn_cast<BitCastOperator>(U))
70      findUses(BC, F, Uses);
71    else if (auto *A = dyn_cast<GlobalAlias>(U))
72      findUses(A, F, Uses);
73    else if (auto *CB = dyn_cast<CallBase>(U)) {
74      Value *Callee = CB->getCalledOperand();
75      if (Callee != V)
76        // Skip calls where the function isn't the callee
77        continue;
78      if (CB->getFunctionType() == F.getValueType())
79        // Skip uses that are immediately called
80        continue;
81      Uses.push_back(std::make_pair(CB, &F));
82    }
83  }
84}
85
86// Create a wrapper function with type Ty that calls F (which may have a
87// different type). Attempt to support common bitcasted function idioms:
88//  - Call with more arguments than needed: arguments are dropped
89//  - Call with fewer arguments than needed: arguments are filled in with undef
90//  - Return value is not needed: drop it
91//  - Return value needed but not present: supply an undef
92//
93// If the all the argument types of trivially castable to one another (i.e.
94// I32 vs pointer type) then we don't create a wrapper at all (return nullptr
95// instead).
96//
97// If there is a type mismatch that we know would result in an invalid wasm
98// module then generate wrapper that contains unreachable (i.e. abort at
99// runtime).  Such programs are deep into undefined behaviour territory,
100// but we choose to fail at runtime rather than generate and invalid module
101// or fail at compiler time.  The reason we delay the error is that we want
102// to support the CMake which expects to be able to compile and link programs
103// that refer to functions with entirely incorrect signatures (this is how
104// CMake detects the existence of a function in a toolchain).
105//
106// For bitcasts that involve struct types we don't know at this stage if they
107// would be equivalent at the wasm level and so we can't know if we need to
108// generate a wrapper.
109static Function *createWrapper(Function *F, FunctionType *Ty) {
110  Module *M = F->getParent();
111
112  Function *Wrapper = Function::Create(Ty, Function::PrivateLinkage,
113                                       F->getName() + "_bitcast", M);
114  BasicBlock *BB = BasicBlock::Create(M->getContext(), "body", Wrapper);
115  const DataLayout &DL = BB->getModule()->getDataLayout();
116
117  // Determine what arguments to pass.
118  SmallVector<Value *, 4> Args;
119  Function::arg_iterator AI = Wrapper->arg_begin();
120  Function::arg_iterator AE = Wrapper->arg_end();
121  FunctionType::param_iterator PI = F->getFunctionType()->param_begin();
122  FunctionType::param_iterator PE = F->getFunctionType()->param_end();
123  bool TypeMismatch = false;
124  bool WrapperNeeded = false;
125
126  Type *ExpectedRtnType = F->getFunctionType()->getReturnType();
127  Type *RtnType = Ty->getReturnType();
128
129  if ((F->getFunctionType()->getNumParams() != Ty->getNumParams()) ||
130      (F->getFunctionType()->isVarArg() != Ty->isVarArg()) ||
131      (ExpectedRtnType != RtnType))
132    WrapperNeeded = true;
133
134  for (; AI != AE && PI != PE; ++AI, ++PI) {
135    Type *ArgType = AI->getType();
136    Type *ParamType = *PI;
137
138    if (ArgType == ParamType) {
139      Args.push_back(&*AI);
140    } else {
141      if (CastInst::isBitOrNoopPointerCastable(ArgType, ParamType, DL)) {
142        Instruction *PtrCast =
143            CastInst::CreateBitOrPointerCast(AI, ParamType, "cast");
144        PtrCast->insertInto(BB, BB->end());
145        Args.push_back(PtrCast);
146      } else if (ArgType->isStructTy() || ParamType->isStructTy()) {
147        LLVM_DEBUG(dbgs() << "createWrapper: struct param type in bitcast: "
148                          << F->getName() << "\n");
149        WrapperNeeded = false;
150      } else {
151        LLVM_DEBUG(dbgs() << "createWrapper: arg type mismatch calling: "
152                          << F->getName() << "\n");
153        LLVM_DEBUG(dbgs() << "Arg[" << Args.size() << "] Expected: "
154                          << *ParamType << " Got: " << *ArgType << "\n");
155        TypeMismatch = true;
156        break;
157      }
158    }
159  }
160
161  if (WrapperNeeded && !TypeMismatch) {
162    for (; PI != PE; ++PI)
163      Args.push_back(UndefValue::get(*PI));
164    if (F->isVarArg())
165      for (; AI != AE; ++AI)
166        Args.push_back(&*AI);
167
168    CallInst *Call = CallInst::Create(F, Args, "", BB);
169
170    Type *ExpectedRtnType = F->getFunctionType()->getReturnType();
171    Type *RtnType = Ty->getReturnType();
172    // Determine what value to return.
173    if (RtnType->isVoidTy()) {
174      ReturnInst::Create(M->getContext(), BB);
175    } else if (ExpectedRtnType->isVoidTy()) {
176      LLVM_DEBUG(dbgs() << "Creating dummy return: " << *RtnType << "\n");
177      ReturnInst::Create(M->getContext(), UndefValue::get(RtnType), BB);
178    } else if (RtnType == ExpectedRtnType) {
179      ReturnInst::Create(M->getContext(), Call, BB);
180    } else if (CastInst::isBitOrNoopPointerCastable(ExpectedRtnType, RtnType,
181                                                    DL)) {
182      Instruction *Cast =
183          CastInst::CreateBitOrPointerCast(Call, RtnType, "cast");
184      Cast->insertInto(BB, BB->end());
185      ReturnInst::Create(M->getContext(), Cast, BB);
186    } else if (RtnType->isStructTy() || ExpectedRtnType->isStructTy()) {
187      LLVM_DEBUG(dbgs() << "createWrapper: struct return type in bitcast: "
188                        << F->getName() << "\n");
189      WrapperNeeded = false;
190    } else {
191      LLVM_DEBUG(dbgs() << "createWrapper: return type mismatch calling: "
192                        << F->getName() << "\n");
193      LLVM_DEBUG(dbgs() << "Expected: " << *ExpectedRtnType
194                        << " Got: " << *RtnType << "\n");
195      TypeMismatch = true;
196    }
197  }
198
199  if (TypeMismatch) {
200    // Create a new wrapper that simply contains `unreachable`.
201    Wrapper->eraseFromParent();
202    Wrapper = Function::Create(Ty, Function::PrivateLinkage,
203                               F->getName() + "_bitcast_invalid", M);
204    BasicBlock *BB = BasicBlock::Create(M->getContext(), "body", Wrapper);
205    new UnreachableInst(M->getContext(), BB);
206    Wrapper->setName(F->getName() + "_bitcast_invalid");
207  } else if (!WrapperNeeded) {
208    LLVM_DEBUG(dbgs() << "createWrapper: no wrapper needed: " << F->getName()
209                      << "\n");
210    Wrapper->eraseFromParent();
211    return nullptr;
212  }
213  LLVM_DEBUG(dbgs() << "createWrapper: " << F->getName() << "\n");
214  return Wrapper;
215}
216
217// Test whether a main function with type FuncTy should be rewritten to have
218// type MainTy.
219static bool shouldFixMainFunction(FunctionType *FuncTy, FunctionType *MainTy) {
220  // Only fix the main function if it's the standard zero-arg form. That way,
221  // the standard cases will work as expected, and users will see signature
222  // mismatches from the linker for non-standard cases.
223  return FuncTy->getReturnType() == MainTy->getReturnType() &&
224         FuncTy->getNumParams() == 0 &&
225         !FuncTy->isVarArg();
226}
227
228bool FixFunctionBitcasts::runOnModule(Module &M) {
229  LLVM_DEBUG(dbgs() << "********** Fix Function Bitcasts **********\n");
230
231  Function *Main = nullptr;
232  CallInst *CallMain = nullptr;
233  SmallVector<std::pair<CallBase *, Function *>, 0> Uses;
234
235  // Collect all the places that need wrappers.
236  for (Function &F : M) {
237    // Skip to fix when the function is swiftcc because swiftcc allows
238    // bitcast type difference for swiftself and swifterror.
239    if (F.getCallingConv() == CallingConv::Swift)
240      continue;
241    findUses(&F, F, Uses);
242
243    // If we have a "main" function, and its type isn't
244    // "int main(int argc, char *argv[])", create an artificial call with it
245    // bitcasted to that type so that we generate a wrapper for it, so that
246    // the C runtime can call it.
247    if (F.getName() == "main") {
248      Main = &F;
249      LLVMContext &C = M.getContext();
250      Type *MainArgTys[] = {Type::getInt32Ty(C),
251                            PointerType::get(Type::getInt8PtrTy(C), 0)};
252      FunctionType *MainTy = FunctionType::get(Type::getInt32Ty(C), MainArgTys,
253                                               /*isVarArg=*/false);
254      if (shouldFixMainFunction(F.getFunctionType(), MainTy)) {
255        LLVM_DEBUG(dbgs() << "Found `main` function with incorrect type: "
256                          << *F.getFunctionType() << "\n");
257        Value *Args[] = {UndefValue::get(MainArgTys[0]),
258                         UndefValue::get(MainArgTys[1])};
259        Value *Casted =
260            ConstantExpr::getBitCast(Main, PointerType::get(MainTy, 0));
261        CallMain = CallInst::Create(MainTy, Casted, Args, "call_main");
262        Uses.push_back(std::make_pair(CallMain, &F));
263      }
264    }
265  }
266
267  DenseMap<std::pair<Function *, FunctionType *>, Function *> Wrappers;
268
269  for (auto &UseFunc : Uses) {
270    CallBase *CB = UseFunc.first;
271    Function *F = UseFunc.second;
272    FunctionType *Ty = CB->getFunctionType();
273
274    auto Pair = Wrappers.insert(std::make_pair(std::make_pair(F, Ty), nullptr));
275    if (Pair.second)
276      Pair.first->second = createWrapper(F, Ty);
277
278    Function *Wrapper = Pair.first->second;
279    if (!Wrapper)
280      continue;
281
282    CB->setCalledOperand(Wrapper);
283  }
284
285  // If we created a wrapper for main, rename the wrapper so that it's the
286  // one that gets called from startup.
287  if (CallMain) {
288    Main->setName("__original_main");
289    auto *MainWrapper =
290        cast<Function>(CallMain->getCalledOperand()->stripPointerCasts());
291    delete CallMain;
292    if (Main->isDeclaration()) {
293      // The wrapper is not needed in this case as we don't need to export
294      // it to anyone else.
295      MainWrapper->eraseFromParent();
296    } else {
297      // Otherwise give the wrapper the same linkage as the original main
298      // function, so that it can be called from the same places.
299      MainWrapper->setName("main");
300      MainWrapper->setLinkage(Main->getLinkage());
301      MainWrapper->setVisibility(Main->getVisibility());
302    }
303  }
304
305  return true;
306}
307