From: Daniel Dunbar Date: Sat, 23 Aug 2008 03:10:25 +0000 (+0000) Subject: Move [LR]Value into CGValue.h X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=2eecaab0fa5f569c3de82a7f04c5dc39298f472d;p=clang Move [LR]Value into CGValue.h - No (intended) functional change. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@55221 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/CodeGen/CGValue.h b/lib/CodeGen/CGValue.h new file mode 100644 index 0000000000..ba4ea0e6c8 --- /dev/null +++ b/lib/CodeGen/CGValue.h @@ -0,0 +1,208 @@ +//===-- CGValue.h - LLVM CodeGen wrappers for llvm::Value* ------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// These classes implement wrappers around llvm::Value in order to +// fully represent the range of values for C L- and R- values. +// +//===----------------------------------------------------------------------===// + +#ifndef CLANG_CODEGEN_CGVALUE_H +#define CLANG_CODEGEN_CGVALUE_H + +#include "clang/AST/Type.h" + +namespace clang { +namespace CodeGen { + +/// RValue - This trivial value class is used to represent the result of an +/// expression that is evaluated. It can be one of three things: either a +/// simple LLVM SSA value, a pair of SSA values for complex numbers, or the +/// address of an aggregate value in memory. +class RValue { + llvm::Value *V1, *V2; + // TODO: Encode this into the low bit of pointer for more efficient + // return-by-value. + enum { Scalar, Complex, Aggregate } Flavor; + + // FIXME: Aggregate rvalues need to retain information about whether they are + // volatile or not. +public: + + bool isScalar() const { return Flavor == Scalar; } + bool isComplex() const { return Flavor == Complex; } + bool isAggregate() const { return Flavor == Aggregate; } + + /// getScalar() - Return the Value* of this scalar value. + llvm::Value *getScalarVal() const { + assert(isScalar() && "Not a scalar!"); + return V1; + } + + /// getComplexVal - Return the real/imag components of this complex value. + /// + std::pair getComplexVal() const { + return std::pair(V1, V2); + } + + /// getAggregateAddr() - Return the Value* of the address of the aggregate. + llvm::Value *getAggregateAddr() const { + assert(isAggregate() && "Not an aggregate!"); + return V1; + } + + static RValue get(llvm::Value *V) { + RValue ER; + ER.V1 = V; + ER.Flavor = Scalar; + return ER; + } + static RValue getComplex(llvm::Value *V1, llvm::Value *V2) { + RValue ER; + ER.V1 = V1; + ER.V2 = V2; + ER.Flavor = Complex; + return ER; + } + static RValue getComplex(const std::pair &C) { + RValue ER; + ER.V1 = C.first; + ER.V2 = C.second; + ER.Flavor = Complex; + return ER; + } + static RValue getAggregate(llvm::Value *V) { + RValue ER; + ER.V1 = V; + ER.Flavor = Aggregate; + return ER; + } +}; + + +/// LValue - This represents an lvalue references. Because C/C++ allow +/// bitfields, this is not a simple LLVM pointer, it may be a pointer plus a +/// bitrange. +class LValue { + // FIXME: alignment? + + enum { + Simple, // This is a normal l-value, use getAddress(). + VectorElt, // This is a vector element l-value (V[i]), use getVector* + BitField, // This is a bitfield l-value, use getBitfield*. + ExtVectorElt // This is an extended vector subset, use getExtVectorComp + } LVType; + + llvm::Value *V; + + union { + // Index into a vector subscript: V[i] + llvm::Value *VectorIdx; + + // ExtVector element subset: V.xyx + llvm::Constant *VectorElts; + + // BitField start bit and size + struct { + unsigned short StartBit; + unsigned short Size; + bool IsSigned; + } BitfieldData; + }; + + bool Volatile:1; + // FIXME: set but never used, what effect should it have? + bool Restrict:1; + +private: + static void SetQualifiers(unsigned Qualifiers, LValue& R) { + R.Volatile = (Qualifiers&QualType::Volatile)!=0; + R.Restrict = (Qualifiers&QualType::Restrict)!=0; + } + +public: + bool isSimple() const { return LVType == Simple; } + bool isVectorElt() const { return LVType == VectorElt; } + bool isBitfield() const { return LVType == BitField; } + bool isExtVectorElt() const { return LVType == ExtVectorElt; } + + bool isVolatileQualified() const { return Volatile; } + bool isRestrictQualified() const { return Restrict; } + + // simple lvalue + llvm::Value *getAddress() const { assert(isSimple()); return V; } + // vector elt lvalue + llvm::Value *getVectorAddr() const { assert(isVectorElt()); return V; } + llvm::Value *getVectorIdx() const { assert(isVectorElt()); return VectorIdx; } + // extended vector elements. + llvm::Value *getExtVectorAddr() const { assert(isExtVectorElt()); return V; } + llvm::Constant *getExtVectorElts() const { + assert(isExtVectorElt()); + return VectorElts; + } + // bitfield lvalue + llvm::Value *getBitfieldAddr() const { assert(isBitfield()); return V; } + unsigned short getBitfieldStartBit() const { + assert(isBitfield()); + return BitfieldData.StartBit; + } + unsigned short getBitfieldSize() const { + assert(isBitfield()); + return BitfieldData.Size; + } + bool isBitfieldSigned() const { + assert(isBitfield()); + return BitfieldData.IsSigned; + } + + static LValue MakeAddr(llvm::Value *V, unsigned Qualifiers) { + LValue R; + R.LVType = Simple; + R.V = V; + SetQualifiers(Qualifiers,R); + return R; + } + + static LValue MakeVectorElt(llvm::Value *Vec, llvm::Value *Idx, + unsigned Qualifiers) { + LValue R; + R.LVType = VectorElt; + R.V = Vec; + R.VectorIdx = Idx; + SetQualifiers(Qualifiers,R); + return R; + } + + static LValue MakeExtVectorElt(llvm::Value *Vec, llvm::Constant *Elts, + unsigned Qualifiers) { + LValue R; + R.LVType = ExtVectorElt; + R.V = Vec; + R.VectorElts = Elts; + SetQualifiers(Qualifiers,R); + return R; + } + + static LValue MakeBitfield(llvm::Value *V, unsigned short StartBit, + unsigned short Size, bool IsSigned, + unsigned Qualifiers) { + LValue R; + R.LVType = BitField; + R.V = V; + R.BitfieldData.StartBit = StartBit; + R.BitfieldData.Size = Size; + R.BitfieldData.IsSigned = IsSigned; + SetQualifiers(Qualifiers,R); + return R; + } +}; + +} // end namespace CodeGen +} // end namespace clang + +#endif diff --git a/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h index cf057d8edb..f13cba2a44 100644 --- a/lib/CodeGen/CodeGenFunction.h +++ b/lib/CodeGen/CodeGenFunction.h @@ -29,6 +29,8 @@ namespace llvm { class Module; } +#include "CGValue.h" + namespace clang { class ASTContext; class Decl; @@ -45,188 +47,6 @@ namespace CodeGen { class CodeGenTypes; class CGRecordLayout; -/// RValue - This trivial value class is used to represent the result of an -/// expression that is evaluated. It can be one of three things: either a -/// simple LLVM SSA value, a pair of SSA values for complex numbers, or the -/// address of an aggregate value in memory. -class RValue { - llvm::Value *V1, *V2; - // TODO: Encode this into the low bit of pointer for more efficient - // return-by-value. - enum { Scalar, Complex, Aggregate } Flavor; - - // FIXME: Aggregate rvalues need to retain information about whether they are - // volatile or not. -public: - - bool isScalar() const { return Flavor == Scalar; } - bool isComplex() const { return Flavor == Complex; } - bool isAggregate() const { return Flavor == Aggregate; } - - /// getScalar() - Return the Value* of this scalar value. - llvm::Value *getScalarVal() const { - assert(isScalar() && "Not a scalar!"); - return V1; - } - - /// getComplexVal - Return the real/imag components of this complex value. - /// - std::pair getComplexVal() const { - return std::pair(V1, V2); - } - - /// getAggregateAddr() - Return the Value* of the address of the aggregate. - llvm::Value *getAggregateAddr() const { - assert(isAggregate() && "Not an aggregate!"); - return V1; - } - - static RValue get(llvm::Value *V) { - RValue ER; - ER.V1 = V; - ER.Flavor = Scalar; - return ER; - } - static RValue getComplex(llvm::Value *V1, llvm::Value *V2) { - RValue ER; - ER.V1 = V1; - ER.V2 = V2; - ER.Flavor = Complex; - return ER; - } - static RValue getComplex(const std::pair &C) { - RValue ER; - ER.V1 = C.first; - ER.V2 = C.second; - ER.Flavor = Complex; - return ER; - } - static RValue getAggregate(llvm::Value *V) { - RValue ER; - ER.V1 = V; - ER.Flavor = Aggregate; - return ER; - } -}; - - -/// LValue - This represents an lvalue references. Because C/C++ allow -/// bitfields, this is not a simple LLVM pointer, it may be a pointer plus a -/// bitrange. -class LValue { - // FIXME: alignment? - - enum { - Simple, // This is a normal l-value, use getAddress(). - VectorElt, // This is a vector element l-value (V[i]), use getVector* - BitField, // This is a bitfield l-value, use getBitfield*. - ExtVectorElt // This is an extended vector subset, use getExtVectorComp - } LVType; - - llvm::Value *V; - - union { - // Index into a vector subscript: V[i] - llvm::Value *VectorIdx; - - // ExtVector element subset: V.xyx - llvm::Constant *VectorElts; - - // BitField start bit and size - struct { - unsigned short StartBit; - unsigned short Size; - bool IsSigned; - } BitfieldData; - }; - - bool Volatile:1; - // FIXME: set but never used, what effect should it have? - bool Restrict:1; - -private: - static void SetQualifiers(unsigned Qualifiers, LValue& R) { - R.Volatile = (Qualifiers&QualType::Volatile)!=0; - R.Restrict = (Qualifiers&QualType::Restrict)!=0; - } - -public: - bool isSimple() const { return LVType == Simple; } - bool isVectorElt() const { return LVType == VectorElt; } - bool isBitfield() const { return LVType == BitField; } - bool isExtVectorElt() const { return LVType == ExtVectorElt; } - - bool isVolatileQualified() const { return Volatile; } - bool isRestrictQualified() const { return Restrict; } - - // simple lvalue - llvm::Value *getAddress() const { assert(isSimple()); return V; } - // vector elt lvalue - llvm::Value *getVectorAddr() const { assert(isVectorElt()); return V; } - llvm::Value *getVectorIdx() const { assert(isVectorElt()); return VectorIdx; } - // extended vector elements. - llvm::Value *getExtVectorAddr() const { assert(isExtVectorElt()); return V; } - llvm::Constant *getExtVectorElts() const { - assert(isExtVectorElt()); - return VectorElts; - } - // bitfield lvalue - llvm::Value *getBitfieldAddr() const { assert(isBitfield()); return V; } - unsigned short getBitfieldStartBit() const { - assert(isBitfield()); - return BitfieldData.StartBit; - } - unsigned short getBitfieldSize() const { - assert(isBitfield()); - return BitfieldData.Size; - } - bool isBitfieldSigned() const { - assert(isBitfield()); - return BitfieldData.IsSigned; - } - - static LValue MakeAddr(llvm::Value *V, unsigned Qualifiers) { - LValue R; - R.LVType = Simple; - R.V = V; - SetQualifiers(Qualifiers,R); - return R; - } - - static LValue MakeVectorElt(llvm::Value *Vec, llvm::Value *Idx, - unsigned Qualifiers) { - LValue R; - R.LVType = VectorElt; - R.V = Vec; - R.VectorIdx = Idx; - SetQualifiers(Qualifiers,R); - return R; - } - - static LValue MakeExtVectorElt(llvm::Value *Vec, llvm::Constant *Elts, - unsigned Qualifiers) { - LValue R; - R.LVType = ExtVectorElt; - R.V = Vec; - R.VectorElts = Elts; - SetQualifiers(Qualifiers,R); - return R; - } - - static LValue MakeBitfield(llvm::Value *V, unsigned short StartBit, - unsigned short Size, bool IsSigned, - unsigned Qualifiers) { - LValue R; - R.LVType = BitField; - R.V = V; - R.BitfieldData.StartBit = StartBit; - R.BitfieldData.Size = Size; - R.BitfieldData.IsSigned = IsSigned; - SetQualifiers(Qualifiers,R); - return R; - } -}; - /// CodeGenFunction - This class organizes the per-function state that is used /// while generating LLVM code. class CodeGenFunction {