mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 02:52:53 +02:00
dad288658b
To support spilling/filling of scalable vectors we need a more generic
representation of a stack offset than simply 'int'.
For this we introduce the StackOffset struct, which comprises multiple
offsets sized by their respective MVTs. Byte-offsets will thus be a simple
tuple such as { offset, MVT::i8 }. Adding two byte-offsets will result in a
byte offset { offsetA + offsetB, MVT::i8 }. When two offsets have different
types, we can canonicalise them to use the same MVT, as long as their
runtime sizes are guaranteed to have the same size-ratio as they would have
at compile-time.
When we have both scalable- and fixed-size objects on the stack, we can
create an offset that is:
({ offset_fixed, MVT::i8 } + { offset_scalable, MVT::nxv1i8 })
The struct also contains a getForFrameOffset() method that is specific to
AArch64 and decomposes the frame-offset to be used directly in instructions
that operate on the stack or index into the stack.
Note: This patch adds StackOffset as an AArch64-only concept, but we would
like to make this a generic concept/struct that is supported by all
interfaces that take or return stack offsets (currently as 'int'). Since
that would be a bigger change that is currently pending on D32530 landing,
we thought it makes sense to first show/prove the concept in the AArch64
target before proposing to roll this out further.
Reviewers: thegameg, rovka, t.p.northover, efriedma, greened
Reviewed By: rovka, greened
Differential Revision: https://reviews.llvm.org/D61435
llvm-svn: 368024
106 lines
3.1 KiB
C++
106 lines
3.1 KiB
C++
//==--AArch64StackOffset.h ---------------------------------------*- 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 contains the declaration of the StackOffset class, which is used to
|
|
// describe scalable and non-scalable offsets during frame lowering.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIB_TARGET_AARCH64_AARCH64STACKOFFSET_H
|
|
#define LLVM_LIB_TARGET_AARCH64_AARCH64STACKOFFSET_H
|
|
|
|
#include "llvm/Support/MachineValueType.h"
|
|
|
|
namespace llvm {
|
|
|
|
/// StackOffset is a wrapper around scalable and non-scalable offsets and is
|
|
/// used in several functions such as 'isAArch64FrameOffsetLegal' and
|
|
/// 'emitFrameOffset()'. StackOffsets are described by MVTs, e.g.
|
|
//
|
|
/// StackOffset(1, MVT::nxv16i8)
|
|
//
|
|
/// would describe an offset as being the size of a single SVE vector.
|
|
///
|
|
/// The class also implements simple arithmetic (addition/subtraction) on these
|
|
/// offsets, e.g.
|
|
//
|
|
/// StackOffset(1, MVT::nxv16i8) + StackOffset(1, MVT::i64)
|
|
//
|
|
/// describes an offset that spans the combined storage required for an SVE
|
|
/// vector and a 64bit GPR.
|
|
class StackOffset {
|
|
int64_t Bytes;
|
|
|
|
explicit operator int() const;
|
|
|
|
public:
|
|
using Part = std::pair<int64_t, MVT>;
|
|
|
|
StackOffset() : Bytes(0) {}
|
|
|
|
StackOffset(int64_t Offset, MVT::SimpleValueType T) : StackOffset() {
|
|
assert(!MVT(T).isScalableVector() && "Scalable types not supported");
|
|
*this += Part(Offset, T);
|
|
}
|
|
|
|
StackOffset(const StackOffset &Other) : Bytes(Other.Bytes) {}
|
|
|
|
StackOffset &operator=(const StackOffset &) = default;
|
|
|
|
StackOffset &operator+=(const StackOffset::Part &Other) {
|
|
assert(Other.second.getSizeInBits() % 8 == 0 &&
|
|
"Offset type is not a multiple of bytes");
|
|
Bytes += Other.first * (Other.second.getSizeInBits() / 8);
|
|
return *this;
|
|
}
|
|
|
|
StackOffset &operator+=(const StackOffset &Other) {
|
|
Bytes += Other.Bytes;
|
|
return *this;
|
|
}
|
|
|
|
StackOffset operator+(const StackOffset &Other) const {
|
|
StackOffset Res(*this);
|
|
Res += Other;
|
|
return Res;
|
|
}
|
|
|
|
StackOffset &operator-=(const StackOffset &Other) {
|
|
Bytes -= Other.Bytes;
|
|
return *this;
|
|
}
|
|
|
|
StackOffset operator-(const StackOffset &Other) const {
|
|
StackOffset Res(*this);
|
|
Res -= Other;
|
|
return Res;
|
|
}
|
|
|
|
StackOffset operator-() const {
|
|
StackOffset Res = {};
|
|
const StackOffset Other(*this);
|
|
Res -= Other;
|
|
return Res;
|
|
}
|
|
|
|
/// Returns the non-scalable part of the offset in bytes.
|
|
int64_t getBytes() const { return Bytes; }
|
|
|
|
/// Returns the offset in parts to which this frame offset can be
|
|
/// decomposed for the purpose of describing a frame offset.
|
|
/// For non-scalable offsets this is simply its byte size.
|
|
void getForFrameOffset(int64_t &ByteSized) const { ByteSized = Bytes; }
|
|
|
|
/// Returns whether the offset is known zero.
|
|
explicit operator bool() const { return Bytes; }
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif
|