mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-19 01:34:32 +00:00
851b04c920
This change, which allows @llvm.assume to be used from within computeKnownBits (and other associated functions in ValueTracking), adds some (optional) parameters to computeKnownBits and friends. These functions now (optionally) take a "context" instruction pointer, an AssumptionTracker pointer, and also a DomTree pointer, and most of the changes are just to pass this new information when it is easily available from InstSimplify, InstCombine, etc. As explained below, the significant conceptual change is that known properties of a value might depend on the control-flow location of the use (because we care that the @llvm.assume dominates the use because assumptions have control-flow dependencies). This means that, when we ask if bits are known in a value, we might get different answers for different uses. The significant changes are all in ValueTracking. Two main changes: First, as with the rest of the code, new parameters need to be passed around. To make this easier, I grouped them into a structure, and I made internal static versions of the relevant functions that take this structure as a parameter. The new code does as you might expect, it looks for @llvm.assume calls that make use of the value we're trying to learn something about (often indirectly), attempts to pattern match that expression, and uses the result if successful. By making use of the AssumptionTracker, the process of finding @llvm.assume calls is not expensive. Part of the structure being passed around inside ValueTracking is a set of already-considered @llvm.assume calls. This is to prevent a query using, for example, the assume(a == b), to recurse on itself. The context and DT params are used to find applicable assumptions. An assumption needs to dominate the context instruction, or come after it deterministically. In this latter case we only handle the specific case where both the assumption and the context instruction are in the same block, and we need to exclude assumptions from being used to simplify their own ephemeral values (those which contribute only to the assumption) because otherwise the assumption would prove its feeding comparison trivial and would be removed. This commit adds the plumbing and the logic for a simple masked-bit propagation (just enough to write a regression test). Future commits add more patterns (and, correspondingly, more regression tests). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@217342 91177308-0d34-0410-b5e6-96231b3b80d8
51 lines
1.7 KiB
C++
51 lines
1.7 KiB
C++
//===- PromoteMemToReg.h - Promote Allocas to Scalars -----------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file exposes an interface to promote alloca instructions to SSA
|
|
// registers, by using the SSA construction algorithm.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_TRANSFORMS_UTILS_PROMOTEMEMTOREG_H
|
|
#define LLVM_TRANSFORMS_UTILS_PROMOTEMEMTOREG_H
|
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
|
|
namespace llvm {
|
|
|
|
class AllocaInst;
|
|
class DominatorTree;
|
|
class AliasSetTracker;
|
|
class AssumptionTracker;
|
|
|
|
/// \brief Return true if this alloca is legal for promotion.
|
|
///
|
|
/// This is true if there are only loads, stores, and lifetime markers
|
|
/// (transitively) using this alloca. This also enforces that there is only
|
|
/// ever one layer of bitcasts or GEPs between the alloca and the lifetime
|
|
/// markers.
|
|
bool isAllocaPromotable(const AllocaInst *AI);
|
|
|
|
/// \brief Promote the specified list of alloca instructions into scalar
|
|
/// registers, inserting PHI nodes as appropriate.
|
|
///
|
|
/// This function makes use of DominanceFrontier information. This function
|
|
/// does not modify the CFG of the function at all. All allocas must be from
|
|
/// the same function.
|
|
///
|
|
/// If AST is specified, the specified tracker is updated to reflect changes
|
|
/// made to the IR.
|
|
void PromoteMemToReg(ArrayRef<AllocaInst *> Allocas, DominatorTree &DT,
|
|
AliasSetTracker *AST = nullptr,
|
|
AssumptionTracker *AT = nullptr);
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|