Utils.h

Go to the documentation of this file.

//===- Utils.h - Utilities for gradient interfaces -------* 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
//
//===----------------------------------------------------------------------===//
#pragma once
 
#include "mlir/IR/Builders.h"
#include "mlir/IR/Operation.h"
#include "mlir/Interfaces/FunctionInterfaces.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
 
namespace mlir {
namespace enzyme {
class MGradientUtils;
namespace oputils {
 
const std::set<std::string> &getNonCapturingFunctions();
 
// Checks whether a value escapes through its uses, following view results.
// If seenuse is provided, sets it to true when potentialUser is encountered.
bool isCaptured(Value v, Operation *potentialUser = nullptr,
                bool *seenuse = nullptr);
 
// Checks if the operation/function has any memory write effects. This enables
// batching specific AD optimiziations(which are triggered only if the primal
// function doesnt modify memory operands)
bool isReadOnly(Operation *op);
 
bool isReadNone(Operation *op);
 
// The shadow of a stored value nothing differentiates is the primal value
// itself: the shadow memory's structural fields must read as the primal's.
// If the activity given was wrong about the value, only runtime activity
// could catch it; every site says so through here, so a future runtime
// activity implementation has a single seam to take over (as EnzymeLLVM's
// does).
Value inactiveStoredValueShadow(Operation *orig, MGradientUtils &gutils,
                                Value stored, OpBuilder &builder);
 
// Walks a pointer-like value to the object it is derived from, looking
// through view-like ops (memref.cast, memref.memory_space_cast, subviews),
// llvm.getelementptr, llvm.bitcast, and llvm.addrspacecast. If offsetAllowed is
// false, only follow operations known to preserve the starting address.
Value getBaseObject(Value v, bool offsetAllowed = true);
 
// Checks if 2 values v1 and v2 may alias with each other locally
bool mayAlias(Value v1, Value v2);
 
// check if 2 memory effects' underlying values alias with each other
bool mayAlias(MemoryEffects::EffectInstance &A,
              MemoryEffects::EffectInstance &B);
 
// check if a memory effect's underlying values alias with a value
bool mayAlias(mlir::MemoryEffects::EffectInstance a, mlir::Value v2);
 
/// Returns the side effects of an operation(similar to
/// `mlir::getEffectsRecursively`). If the operation has RecursiveMemoryEffects,
/// include all side effects of child operations.
///
/// Also accounts for LLVM and autodiff-specific memory effects which are not
/// captured by the default `mlir::getEffectsRecursively`
bool collectOpEffects(Operation *rootOp,
                      SmallVector<MemoryEffects::EffectInstance> &effects);
 
// Specialize memory effect collection for a FunctionOpInterface
SmallVector<MemoryEffects::EffectInstance>
collectFnEffects(FunctionOpInterface fnOp);
 
MemoryEffects::EffectInstance getEffectOfVal(Value val,
                                             MemoryEffects::Effect *effect,
                                             SideEffects::Resource *resource);
} // namespace oputils
} // namespace enzyme
} // namespace mlir