mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 11:13:28 +01:00
db20f1e2c5
Instead, represent the mask as out-of-line data in the instruction. This should be more efficient in the places that currently use getShuffleVector(), and paves the way for further changes to add new shuffles for scalable vectors. This doesn't change the syntax in textual IR. And I don't currently plan to change the bitcode encoding in this patch, although we'll probably need to do something once we extend shufflevector for scalable types. I expect that once this is finished, we can then replace the raw "mask" with something more appropriate for scalable vectors. Not sure exactly what this looks like at the moment, but there are a few different ways we could handle it. Maybe we could try to describe specific shuffles. Or maybe we could define it in terms of a function to convert a fixed-length array into an appropriate scalable vector, using a "step", or something like that. Differential Revision: https://reviews.llvm.org/D72467
57 lines
2.5 KiB
C++
57 lines
2.5 KiB
C++
//===-- ConstantFolding.h - Internal Constant Folding Interface -*- 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the (internal) constant folding interfaces for LLVM. These
|
|
// interfaces are used by the ConstantExpr::get* methods to automatically fold
|
|
// constants when possible.
|
|
//
|
|
// These operators may return a null object if they don't know how to perform
|
|
// the specified operation on the specified constant types.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIB_IR_CONSTANTFOLD_H
|
|
#define LLVM_LIB_IR_CONSTANTFOLD_H
|
|
|
|
#include "llvm/ADT/Optional.h"
|
|
|
|
namespace llvm {
|
|
template <typename T> class ArrayRef;
|
|
class Value;
|
|
class Constant;
|
|
class Type;
|
|
|
|
// Constant fold various types of instruction...
|
|
Constant *ConstantFoldCastInstruction(
|
|
unsigned opcode, ///< The opcode of the cast
|
|
Constant *V, ///< The source constant
|
|
Type *DestTy ///< The destination type
|
|
);
|
|
Constant *ConstantFoldSelectInstruction(Constant *Cond,
|
|
Constant *V1, Constant *V2);
|
|
Constant *ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx);
|
|
Constant *ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt,
|
|
Constant *Idx);
|
|
Constant *ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2,
|
|
ArrayRef<int> Mask);
|
|
Constant *ConstantFoldExtractValueInstruction(Constant *Agg,
|
|
ArrayRef<unsigned> Idxs);
|
|
Constant *ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val,
|
|
ArrayRef<unsigned> Idxs);
|
|
Constant *ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V);
|
|
Constant *ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1,
|
|
Constant *V2);
|
|
Constant *ConstantFoldCompareInstruction(unsigned short predicate,
|
|
Constant *C1, Constant *C2);
|
|
Constant *ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool InBounds,
|
|
Optional<unsigned> InRangeIndex,
|
|
ArrayRef<Value *> Idxs);
|
|
} // End llvm namespace
|
|
|
|
#endif
|