@@ -1083,12 +1083,24 @@ LLVMBool LLVMExtraDominatorTreeBlockDominates(LLVMDominatorTreeRef Tree, LLVMBas
 void LLVMExtraDominatorTreeRecalculate(LLVMDominatorTreeRef Tree, LLVMValueRef F);
 // split the block containing `SplitBefore` before it, and insert a conditional branch on
 // `Cond` to a new block that ends with a branch to the tail of the split block (or with an
-// unreachable). Returns the terminator of the new block. If `Tree` is not NULL, it is
+// unreachable). Returns the terminator of the new block. The conditional branch gets
+// `!prof` branch weights if NumBranchWeights is not 0. If `Tree` is not NULL, it is
 // updated for the changes to the CFG; returns NULL (without changing anything) if it is
 // not a tree for the current entry block of the function containing `SplitBefore`.
 LLVMValueRef LLVMExtraSplitBlockAndInsertIfThen(LLVMValueRef Cond, LLVMValueRef SplitBefore,
                                                 LLVMBool Unreachable,
+                                                const unsigned *BranchWeights,
+                                                unsigned NumBranchWeights,
                                                 LLVMDominatorTreeRef Tree);
+// like LLVMExtraSplitBlockAndInsertIfThen, but branching to one of two new blocks, whose
+// terminators are written to ThenTerm and ElseTerm. Returns false (without changing
+// anything) if `Tree` is not a tree for the function containing `SplitBefore`.
+LLVMBool LLVMExtraSplitBlockAndInsertIfThenElse(LLVMValueRef Cond, LLVMValueRef SplitBefore,
+                                                const unsigned *BranchWeights,
+                                                unsigned NumBranchWeights,
+                                                LLVMDominatorTreeRef Tree,
+                                                LLVMValueRef *ThenTerm,
+                                                LLVMValueRef *ElseTerm);
 
 // whether an instruction is unused and has no side effects, and delete such an instruction
 // together with the operands that become trivially dead (returns false if the instruction
@@ -1114,6 +1126,26 @@ LLVMBool LLVMExtraPromoteMemToReg(LLVMValueRef *Allocas, unsigned NumAllocas,
 LLVMBool LLVMExtraConstantFoldCastOperand(LLVMOpcode Opcode, LLVMValueRef C,
                                           LLVMTypeRef DestTy, LLVMTargetDataRef TD,
                                           LLVMValueRef *Result);
+// simplify an instruction, like InstSimplify, without changing it: returns a simpler value
+// that it is equivalent to, or NULL
+LLVMValueRef LLVMExtraSimplifyInstruction(LLVMValueRef Inst);
+
+// split a basic block before an instruction (with the head bit of the iterator, as for
+// LLVMExtraMoveInstruction), moving the instructions from there on to a new block that the
+// original one branches to, like BasicBlock::splitBasicBlock. Returns the new block.
+LLVMBasicBlockRef LLVMExtraSplitBasicBlock(LLVMBasicBlockRef BB, LLVMValueRef Before,
+                                           LLVMBool Head, const char *Name);
+// inline a call site, like InlineFunction (without updating a call graph or using alias
+// analysis). Returns whether the call was inlined; if not, nothing is changed, and if
+// FailureReason is not NULL, it is set to a message (to be disposed of using
+// LLVMDisposeMessage) that describes why. Like InlineFunction, this doesn't check whether
+// the body of the called function can be inlined (see LLVMExtraIsInlineViable).
+LLVMBool LLVMExtraInlineFunction(LLVMValueRef Call, LLVMBool MergeAttributes,
+                                 LLVMBool InsertLifetime, char **FailureReason);
+// whether the body of a function can be inlined into other functions, like isInlineViable;
+// if not, and FailureReason is not NULL, it is set to a message (to be disposed of using
+// LLVMDisposeMessage) that describes why.
+LLVMBool LLVMExtraIsInlineViable(LLVMValueRef Fn, char **FailureReason);
 
 // target triples, parsed like llvm::Triple(Str) (without normalizing them). The names of
 // the components are those of llvm::Triple::get*TypeName.
 
@@ -1,9 +1,12 @@
 #include "LLVMExtra.h"
 
 #include <llvm/ADT/APInt.h>
+#include <llvm/ADT/SmallPtrSet.h>
 #include <llvm/Analysis/AssumptionCache.h>
 #include <llvm/Analysis/ConstantFolding.h>
 #include <llvm/Analysis/DomTreeUpdater.h>
+#include <llvm/Analysis/InlineCost.h>
+#include <llvm/Analysis/InstructionSimplify.h>
 #include <llvm/Analysis/LazyValueInfo.h>
 #include <llvm/Analysis/LoopInfo.h>
 #include <llvm/Analysis/ScalarEvolution.h>
@@ -13,6 +16,7 @@
 #include <llvm/Analysis/SimplifyQuery.h>
 #endif
 #include <llvm/IR/Attributes.h>
+#include <llvm/IR/CFG.h>
 #include <llvm/IR/ConstantRange.h>
 #include <llvm/IR/Dominators.h>
 #include <llvm/IR/IntrinsicInst.h>
@@ -24,6 +28,7 @@
 #include <llvm/IR/Operator.h>
 #include <llvm/Support/KnownBits.h>
 #include <llvm/Transforms/Utils/BasicBlockUtils.h>
+#include <llvm/Transforms/Utils/Cloning.h>
 #include <llvm/Transforms/Utils/Local.h>
 #include <llvm/Transforms/Utils/PromoteMemToReg.h>
 
@@ -807,22 +812,79 @@ void LLVMExtraDominatorTreeRecalculate(LLVMDominatorTreeRef Tree, LLVMValueRef F
   unwrap(Tree)->recalculate(*unwrap<Function>(F));
 }
 
+// the `!prof` node for the given branch weights, or NULL without weights
+static MDNode *createBranchWeights(LLVMContext &C, const unsigned *Weights,
+                                   unsigned NumWeights) {
+  if (NumWeights == 0)
+    return nullptr;
+  SmallVector<uint32_t, 2> W(Weights, Weights + NumWeights);
+  return MDBuilder(C).createBranchWeights(W);
+}
+
+// whether a dominator tree is one of the function containing an instruction. the root of a
+// tree is the entry block of its function (compared without dereferencing it, as the tree
+// may be stale), and LLVM asserts that blocks are of that function
+static bool isTreeOf(LLVMDominatorTreeRef Tree, Instruction *I) {
+  return unwrap(Tree)->getRoot() == &I->getFunction()->getEntryBlock();
+}
+
 LLVMValueRef LLVMExtraSplitBlockAndInsertIfThen(LLVMValueRef Cond, LLVMValueRef SplitBefore,
                                                 LLVMBool Unreachable,
+                                                const unsigned *BranchWeights,
+                                                unsigned NumBranchWeights,
                                                 LLVMDominatorTreeRef Tree) {
   Instruction *I = unwrap<Instruction>(SplitBefore);
   std::optional<DomTreeUpdater> DTU;
   if (Tree) {
-    // the root of a tree is the entry block of its function (compared without dereferencing
-    // it, as the tree may be stale), and LLVM asserts that blocks are of that function
-    if (unwrap(Tree)->getRoot() != &I->getFunction()->getEntryBlock())
+    if (!isTreeOf(Tree, I))
       return nullptr;
     DTU.emplace(*unwrap(Tree), DomTreeUpdater::UpdateStrategy::Eager);
   }
+  MDNode *Weights = createBranchWeights(I->getContext(), BranchWeights, NumBranchWeights);
   // the overload taking an instruction and a DomTreeUpdater exists in every version
   DomTreeUpdater *Updater = DTU ? &*DTU : nullptr;
-  return wrap(SplitBlockAndInsertIfThen(unwrap(Cond), I, Unreachable,
-                                        /*BranchWeights=*/nullptr, Updater));
+  return wrap(SplitBlockAndInsertIfThen(unwrap(Cond), I, Unreachable, Weights, Updater));
+}
+
+LLVMBool LLVMExtraSplitBlockAndInsertIfThenElse(LLVMValueRef Cond, LLVMValueRef SplitBefore,
+                                                const unsigned *BranchWeights,
+                                                unsigned NumBranchWeights,
+                                                LLVMDominatorTreeRef Tree,
+                                                LLVMValueRef *ThenTerm,
+                                                LLVMValueRef *ElseTerm) {
+  Instruction *I = unwrap<Instruction>(SplitBefore);
+  if (Tree && !isTreeOf(Tree, I))
+    return false;
+  MDNode *Weights = createBranchWeights(I->getContext(), BranchWeights, NumBranchWeights);
+  Instruction *Then, *Else;
+#if LLVM_VERSION_MAJOR >= 16
+  std::optional<DomTreeUpdater> DTU;
+  if (Tree)
+    DTU.emplace(*unwrap(Tree), DomTreeUpdater::UpdateStrategy::Eager);
+  DomTreeUpdater *Updater = DTU ? &*DTU : nullptr;
+  SplitBlockAndInsertIfThenElse(unwrap(Cond), I, &Then, &Else, Weights, Updater);
+#else
+  // LLVM 15 can't update a dominator tree here, so apply the updates that LLVM 16 does
+  BasicBlock *Head = I->getParent();
+  SmallPtrSet<BasicBlock *, 8> UniqueOrigSuccessors(succ_begin(Head), succ_end(Head));
+  SplitBlockAndInsertIfThenElse(unwrap(Cond), I, &Then, &Else, Weights);
+  if (Tree) {
+    BasicBlock *Tail = I->getParent();
+    SmallVector<DominatorTree::UpdateType, 8> Updates;
+    for (BasicBlock *Succ : successors(Head)) {
+      Updates.push_back({DominatorTree::Insert, Head, Succ});
+      Updates.push_back({DominatorTree::Insert, Succ, Tail});
+    }
+    for (BasicBlock *Succ : UniqueOrigSuccessors)
+      Updates.push_back({DominatorTree::Insert, Tail, Succ});
+    for (BasicBlock *Succ : UniqueOrigSuccessors)
+      Updates.push_back({DominatorTree::Delete, Head, Succ});
+    DomTreeUpdater(*unwrap(Tree), DomTreeUpdater::UpdateStrategy::Eager).applyUpdates(Updates);
+  }
+#endif
+  *ThenTerm = wrap(Then);
+  *ElseTerm = wrap(Else);
+  return true;
 }
 
 
@@ -886,3 +948,61 @@ LLVMBool LLVMExtraConstantFoldCastOperand(LLVMOpcode Opcode, LLVMValueRef C,
   *Result = wrap(ConstantFoldCastOperand(Op, Const, Ty, *unwrap(TD)));
   return true;
 }
+
+LLVMValueRef LLVMExtraSimplifyInstruction(LLVMValueRef Inst) {
+  Instruction *I = unwrap<Instruction>(Inst);
+  return wrap(simplifyInstruction(I, SimplifyQuery(I->getModule()->getDataLayout(), I)));
+}
+
+
+// Control flow
+
+LLVMBasicBlockRef LLVMExtraSplitBasicBlock(LLVMBasicBlockRef BB, LLVMValueRef Before,
+                                           LLVMBool Head, const char *Name) {
+  BasicBlock::iterator It = unwrap<Instruction>(Before)->getIterator();
+#if LLVM_VERSION_MAJOR >= 19
+  It.setHeadBit(Head);
+#endif
+  return wrap(unwrap(BB)->splitBasicBlock(It, Name));
+}
+
+
+// Inlining
+
+LLVMBool LLVMExtraInlineFunction(LLVMValueRef Call, LLVMBool MergeAttributes,
+                                 LLVMBool InsertLifetime, char **FailureReason) {
+  CallBase *CB = unwrap<CallBase>(Call);
+  Function *Caller = CB->getCaller();
+  InlineFunctionInfo IFI;
+#if LLVM_VERSION_MAJOR < 22
+  // before checking the personality functions, InlineFunction gives a caller without a GC
+  // strategy the one of the callee, which it doesn't undo when it then fails. it changes
+  // nothing else before failing (it only sets the personality function of a caller that
+  // has none, after which it can't fail anymore), so undo that to leave the IR unchanged.
+  bool CallerHadGC = Caller->hasGC();
+#endif
+#if LLVM_VERSION_MAJOR >= 16
+  InlineResult Result =
+      InlineFunction(*CB, IFI, MergeAttributes, /*CalleeAAR=*/nullptr, InsertLifetime);
+#else
+  // InlineFunction doesn't merge the attributes yet, which its callers did instead
+  Function *Callee = CB->getCalledFunction();
+  InlineResult Result = InlineFunction(*CB, IFI, /*CalleeAAR=*/nullptr, InsertLifetime);
+  if (Result.isSuccess() && MergeAttributes)
+    AttributeFuncs::mergeAttributesForInlining(*Caller, *Callee);
+#endif
+#if LLVM_VERSION_MAJOR < 22
+  if (!Result.isSuccess() && !CallerHadGC)
+    Caller->clearGC();
+#endif
+  if (FailureReason)
+    *FailureReason = Result.isSuccess() ? nullptr : strdup(Result.getFailureReason());
+  return Result.isSuccess();
+}
+
+LLVMBool LLVMExtraIsInlineViable(LLVMValueRef Fn, char **FailureReason) {
+  InlineResult Result = isInlineViable(*unwrap<Function>(Fn));
+  if (FailureReason)
+    *FailureReason = Result.isSuccess() ? nullptr : strdup(Result.getFailureReason());
+  return Result.isSuccess();
+}
@@ -16,13 +16,16 @@ PostDomTree
 dispose(::PostDomTree)
 dominates
 recalculate!
+split_block!
 split_block_and_insert_if_then!
+split_block_and_insert_if_then_else!
 ```
 
-## Constant folding
+## Constant folding and simplification
 
 ```@docs
 constant_fold_cast
+simplify_instruction
 ```
 
 ## Constant ranges and known bits
 
@@ -71,3 +71,10 @@ LLVM.collect_flat_address_operands
 clone_into!
 clone
 ```
+
+## Inlining
+
+```@docs
+inline!
+inline_viability
+```
@@ -44,6 +44,13 @@ The control flow between basic blocks can be inspected using the following prope
   terminator. This view is mutable: `bb.successors[i] = other` changes the destination of
   the terminator.
 
+To create control flow, `split_block!(inst, name)` splits a block in two before an
+instruction, with the first part branching to the second, and
+`split_block_and_insert_if_then!(cond, inst)` additionally inserts a block that only
+executes if a condition holds, and `split_block_and_insert_if_then_else!(cond, inst)` one
+for either outcome. Both can attach branch weights (`weights=(1, 9)`) to the conditional
+branch, and update a dominator tree.
+
 
 ## Instructions
 
 
@@ -1242,8 +1242,12 @@ function LLVMExtraDominatorTreeRecalculate(Tree, F)
     ccall((:LLVMExtraDominatorTreeRecalculate, libLLVMExtra), Cvoid, (LLVMDominatorTreeRef, LLVMValueRef), Tree, F)
 end
 
-function LLVMExtraSplitBlockAndInsertIfThen(Cond, SplitBefore, Unreachable, Tree)
-    ccall((:LLVMExtraSplitBlockAndInsertIfThen, libLLVMExtra), LLVMValueRef, (LLVMValueRef, LLVMValueRef, LLVMBool, LLVMDominatorTreeRef), Cond, SplitBefore, Unreachable, Tree)
+function LLVMExtraSplitBlockAndInsertIfThen(Cond, SplitBefore, Unreachable, BranchWeights, NumBranchWeights, Tree)
+    ccall((:LLVMExtraSplitBlockAndInsertIfThen, libLLVMExtra), LLVMValueRef, (LLVMValueRef, LLVMValueRef, LLVMBool, Ptr{Cuint}, Cuint, LLVMDominatorTreeRef), Cond, SplitBefore, Unreachable, BranchWeights, NumBranchWeights, Tree)
+end
+
+function LLVMExtraSplitBlockAndInsertIfThenElse(Cond, SplitBefore, BranchWeights, NumBranchWeights, Tree, ThenTerm, ElseTerm)
+    ccall((:LLVMExtraSplitBlockAndInsertIfThenElse, libLLVMExtra), LLVMBool, (LLVMValueRef, LLVMValueRef, Ptr{Cuint}, Cuint, LLVMDominatorTreeRef, Ptr{LLVMValueRef}, Ptr{LLVMValueRef}), Cond, SplitBefore, BranchWeights, NumBranchWeights, Tree, ThenTerm, ElseTerm)
 end
 
 function LLVMExtraIsInstructionTriviallyDead(Inst)
@@ -1270,6 +1274,22 @@ function LLVMExtraConstantFoldCastOperand(Opcode, C, DestTy, TD, Result)
     ccall((:LLVMExtraConstantFoldCastOperand, libLLVMExtra), LLVMBool, (LLVMOpcode, LLVMValueRef, LLVMTypeRef, LLVMTargetDataRef, Ptr{LLVMValueRef}), Opcode, C, DestTy, TD, Result)
 end
 
+function LLVMExtraSimplifyInstruction(Inst)
+    ccall((:LLVMExtraSimplifyInstruction, libLLVMExtra), LLVMValueRef, (LLVMValueRef,), Inst)
+end
+
+function LLVMExtraSplitBasicBlock(BB, Before, Head, Name)
+    ccall((:LLVMExtraSplitBasicBlock, libLLVMExtra), LLVMBasicBlockRef, (LLVMBasicBlockRef, LLVMValueRef, LLVMBool, Cstring), BB, Before, Head, Name)
+end
+
+function LLVMExtraInlineFunction(Call, MergeAttributes, InsertLifetime, FailureReason)
+    ccall((:LLVMExtraInlineFunction, libLLVMExtra), LLVMBool, (LLVMValueRef, LLVMBool, LLVMBool, Ptr{Cstring}), Call, MergeAttributes, InsertLifetime, FailureReason)
+end
+
+function LLVMExtraIsInlineViable(Fn, FailureReason)
+    ccall((:LLVMExtraIsInlineViable, libLLVMExtra), LLVMBool, (LLVMValueRef, Ptr{Cstring}), Fn, FailureReason)
+end
+
 function LLVMExtraTripleGetArchTypeName(Triple)
     ccall((:LLVMExtraTripleGetArchTypeName, libLLVMExtra), Cstring, (Cstring,), Triple)
 end
 
@@ -1282,8 +1282,12 @@ function LLVMExtraDominatorTreeRecalculate(Tree, F)
     ccall((:LLVMExtraDominatorTreeRecalculate, libLLVMExtra), Cvoid, (LLVMDominatorTreeRef, LLVMValueRef), Tree, F)
 end
 
-function LLVMExtraSplitBlockAndInsertIfThen(Cond, SplitBefore, Unreachable, Tree)
-    ccall((:LLVMExtraSplitBlockAndInsertIfThen, libLLVMExtra), LLVMValueRef, (LLVMValueRef, LLVMValueRef, LLVMBool, LLVMDominatorTreeRef), Cond, SplitBefore, Unreachable, Tree)
+function LLVMExtraSplitBlockAndInsertIfThen(Cond, SplitBefore, Unreachable, BranchWeights, NumBranchWeights, Tree)
+    ccall((:LLVMExtraSplitBlockAndInsertIfThen, libLLVMExtra), LLVMValueRef, (LLVMValueRef, LLVMValueRef, LLVMBool, Ptr{Cuint}, Cuint, LLVMDominatorTreeRef), Cond, SplitBefore, Unreachable, BranchWeights, NumBranchWeights, Tree)
+end
+
+function LLVMExtraSplitBlockAndInsertIfThenElse(Cond, SplitBefore, BranchWeights, NumBranchWeights, Tree, ThenTerm, ElseTerm)
+    ccall((:LLVMExtraSplitBlockAndInsertIfThenElse, libLLVMExtra), LLVMBool, (LLVMValueRef, LLVMValueRef, Ptr{Cuint}, Cuint, LLVMDominatorTreeRef, Ptr{LLVMValueRef}, Ptr{LLVMValueRef}), Cond, SplitBefore, BranchWeights, NumBranchWeights, Tree, ThenTerm, ElseTerm)
 end
 
 function LLVMExtraIsInstructionTriviallyDead(Inst)
@@ -1310,6 +1314,22 @@ function LLVMExtraConstantFoldCastOperand(Opcode, C, DestTy, TD, Result)
     ccall((:LLVMExtraConstantFoldCastOperand, libLLVMExtra), LLVMBool, (LLVMOpcode, LLVMValueRef, LLVMTypeRef, LLVMTargetDataRef, Ptr{LLVMValueRef}), Opcode, C, DestTy, TD, Result)
 end
 
+function LLVMExtraSimplifyInstruction(Inst)
+    ccall((:LLVMExtraSimplifyInstruction, libLLVMExtra), LLVMValueRef, (LLVMValueRef,), Inst)
+end
+
+function LLVMExtraSplitBasicBlock(BB, Before, Head, Name)
+    ccall((:LLVMExtraSplitBasicBlock, libLLVMExtra), LLVMBasicBlockRef, (LLVMBasicBlockRef, LLVMValueRef, LLVMBool, Cstring), BB, Before, Head, Name)
+end
+
+function LLVMExtraInlineFunction(Call, MergeAttributes, InsertLifetime, FailureReason)
+    ccall((:LLVMExtraInlineFunction, libLLVMExtra), LLVMBool, (LLVMValueRef, LLVMBool, LLVMBool, Ptr{Cstring}), Call, MergeAttributes, InsertLifetime, FailureReason)
+end
+
+function LLVMExtraIsInlineViable(Fn, FailureReason)
+    ccall((:LLVMExtraIsInlineViable, libLLVMExtra), LLVMBool, (LLVMValueRef, Ptr{Cstring}), Fn, FailureReason)
+end
+
 function LLVMExtraTripleGetArchTypeName(Triple)
     ccall((:LLVMExtraTripleGetArchTypeName, libLLVMExtra), Cstring, (Cstring,), Triple)
 end