4625b84879
This supports bitcode compilation using `clang -fwasm-exceptions`. --- The current situation: Currently the backend requires two options for Wasm EH: `-wasm-enable-eh` and `-exception-model=wasm`. Wasm SjLj requires two options as well: `-wasm-enable-sjlj` and `-exception-model=wasm`. When using Wasm EH via Emscripten, you only need to pass `-fwasm-exceptions`, and these options will be added within the clang driver. This description will focus on the case of Wasm EH going forward, but Wasm SjLj's case is similar. When you pass `-fwasm-exceptions` to emcc and clang driver, the clang driver adds these options to the command line that calls the clang frontend (`clang -cc1`): `-mllvm -wasm-enable-eh` and `-exception-model=wasm`. `-wasm-enable-eh` is prefixed with `-mllvm`, so it is passed as is to the backend. But `-exception-model` is parsed and processed within the clang frontend and stored in `LangOptions` class. This info is later transferred to `TargetOptions` class, and then eventually passed to `MCAsmInfo` class. All LLVM code queries this `MCAsmInfo` to get the exception model. --- Problem: The problem is the whole `LangOptions` processing is bypassed when compiling bitcode, so the information transfer of `LangOptions` -> `TargetOptions` -> `MCAsmInfo` does not happen. They are all set to `ExceptionHandling::None`, which is the default value. --- What other targets do, and why we can't do the same: Other targets support bitcode compilation by the clang driver, but they can do that by using different triples. For example, X86 target supports multiple triples, each of which has its own subclass of `MCAsmInfo`, so it can hardcode the appropriate exception model within those subclasses' constructors. But we don't have separate triples for each exception mode: none, emscripten, and wasm. --- What this CL does: If we can figure out whether `-wasm-enable-eh` is passed to the backend, we can programatically set the exception model from the backend, rather than requiring it to be passed. So we check `WasmEnableEH` and `WasmEnableSjLj` variables, which are `cl::opt` for `-wasm-enable-eh` and `-wasm-enable-sjlj`, in `WebAssemblyMCAsmInfo` constructor, and if either of them is set, we set `MCAsmInfo.ExceptionType` to Wasm. `TargetOptions` cannot be updated there, so we make sure they are the same later. Fixes https://github.com/emscripten-core/emscripten/issues/15712. Reviewed By: dschuff Differential Revision: https://reviews.llvm.org/D115893
112 lines
3.9 KiB
C++
112 lines
3.9 KiB
C++
//===-- WebAssemblyUtilities - WebAssembly Utility Functions ---*- C++ -*-====//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// This file contains the declaration of the WebAssembly-specific
|
|
/// utility functions.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIB_TARGET_WEBASSEMBLY_UTILS_WEBASSEMBLYUTILITIES_H
|
|
#define LLVM_LIB_TARGET_WEBASSEMBLY_UTILS_WEBASSEMBLYUTILITIES_H
|
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
namespace llvm {
|
|
|
|
class MachineBasicBlock;
|
|
class MachineInstr;
|
|
class MachineOperand;
|
|
class MCContext;
|
|
class MCSymbolWasm;
|
|
class StringRef;
|
|
class WebAssemblyFunctionInfo;
|
|
class WebAssemblySubtarget;
|
|
|
|
namespace WebAssembly {
|
|
|
|
enum WasmAddressSpace : unsigned {
|
|
// Default address space, for pointers to linear memory (stack, heap, data).
|
|
WASM_ADDRESS_SPACE_DEFAULT = 0,
|
|
// A non-integral address space for pointers to named objects outside of
|
|
// linear memory: WebAssembly globals or WebAssembly locals. Loads and stores
|
|
// to these pointers are lowered to global.get / global.set or local.get /
|
|
// local.set, as appropriate.
|
|
WASM_ADDRESS_SPACE_VAR = 1,
|
|
// A non-integral address space for externref values
|
|
WASM_ADDRESS_SPACE_EXTERNREF = 10,
|
|
// A non-integral address space for funcref values
|
|
WASM_ADDRESS_SPACE_FUNCREF = 20,
|
|
};
|
|
|
|
inline bool isDefaultAddressSpace(unsigned AS) {
|
|
return AS == WASM_ADDRESS_SPACE_DEFAULT;
|
|
}
|
|
inline bool isWasmVarAddressSpace(unsigned AS) {
|
|
return AS == WASM_ADDRESS_SPACE_VAR;
|
|
}
|
|
inline bool isValidAddressSpace(unsigned AS) {
|
|
return isDefaultAddressSpace(AS) || isWasmVarAddressSpace(AS);
|
|
}
|
|
inline bool isFuncrefType(const Type *Ty) {
|
|
return isa<PointerType>(Ty) &&
|
|
Ty->getPointerAddressSpace() ==
|
|
WasmAddressSpace::WASM_ADDRESS_SPACE_FUNCREF;
|
|
}
|
|
inline bool isExternrefType(const Type *Ty) {
|
|
return isa<PointerType>(Ty) &&
|
|
Ty->getPointerAddressSpace() ==
|
|
WasmAddressSpace::WASM_ADDRESS_SPACE_EXTERNREF;
|
|
}
|
|
inline bool isRefType(const Type *Ty) {
|
|
return isFuncrefType(Ty) || isExternrefType(Ty);
|
|
}
|
|
|
|
bool isChild(const MachineInstr &MI, const WebAssemblyFunctionInfo &MFI);
|
|
bool mayThrow(const MachineInstr &MI);
|
|
|
|
// Exception handling / setjmp-longjmp handling command-line options
|
|
extern cl::opt<bool> WasmEnableEmEH; // asm.js-style EH
|
|
extern cl::opt<bool> WasmEnableEmSjLj; // asm.js-style SjLJ
|
|
extern cl::opt<bool> WasmEnableEH; // EH using Wasm EH instructions
|
|
extern cl::opt<bool> WasmEnableSjLj; // SjLj using Wasm EH instructions
|
|
|
|
// Exception-related function names
|
|
extern const char *const ClangCallTerminateFn;
|
|
extern const char *const CxaBeginCatchFn;
|
|
extern const char *const CxaRethrowFn;
|
|
extern const char *const StdTerminateFn;
|
|
extern const char *const PersonalityWrapperFn;
|
|
|
|
/// Returns the operand number of a callee, assuming the argument is a call
|
|
/// instruction.
|
|
const MachineOperand &getCalleeOp(const MachineInstr &MI);
|
|
|
|
/// Returns the __indirect_function_table, for use in call_indirect and in
|
|
/// function bitcasts.
|
|
MCSymbolWasm *
|
|
getOrCreateFunctionTableSymbol(MCContext &Ctx,
|
|
const WebAssemblySubtarget *Subtarget);
|
|
|
|
/// Returns the __funcref_call_table, for use in funcref calls when lowered to
|
|
/// table.set + call_indirect.
|
|
MCSymbolWasm *
|
|
getOrCreateFuncrefCallTableSymbol(MCContext &Ctx,
|
|
const WebAssemblySubtarget *Subtarget);
|
|
|
|
/// Find a catch instruction from an EH pad. Returns null if no catch
|
|
/// instruction found or the catch is in an invalid location.
|
|
MachineInstr *findCatch(MachineBasicBlock *EHPad);
|
|
|
|
} // end namespace WebAssembly
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif
|