Differential D50616 Diff 169716 cfe/trunk/lib/CodeGen/CGExprScalar.cpp

Changeset View

Standalone View

cfe/trunk/lib/CodeGen/CGExprScalar.cpp

//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===//		//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===//
//		//
// The LLVM Compiler Infrastructure		// The LLVM Compiler Infrastructure
//		//
// This file is distributed under the University of Illinois Open Source		// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.		// License. See LICENSE.TXT for details.
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
//		//
// This contains code to emit Expr nodes with scalar LLVM types as LLVM code.		// This contains code to emit Expr nodes with scalar LLVM types as LLVM code.
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "CodeGenFunction.h"
#include "CGCleanup.h"
#include "CGCXXABI.h"		#include "CGCXXABI.h"
		#include "CGCleanup.h"
#include "CGDebugInfo.h"		#include "CGDebugInfo.h"
#include "CGObjCRuntime.h"		#include "CGObjCRuntime.h"
		#include "CodeGenFunction.h"
#include "CodeGenModule.h"		#include "CodeGenModule.h"
#include "TargetInfo.h"		#include "TargetInfo.h"
#include "clang/AST/ASTContext.h"		#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"		#include "clang/AST/DeclObjC.h"
#include "clang/AST/Expr.h"		#include "clang/AST/Expr.h"
#include "clang/AST/RecordLayout.h"		#include "clang/AST/RecordLayout.h"
#include "clang/AST/StmtVisitor.h"		#include "clang/AST/StmtVisitor.h"
		#include "clang/Basic/FixedPoint.h"
#include "clang/Basic/TargetInfo.h"		#include "clang/Basic/TargetInfo.h"
#include "clang/Frontend/CodeGenOptions.h"		#include "clang/Frontend/CodeGenOptions.h"
#include "llvm/ADT/Optional.h"		#include "llvm/ADT/Optional.h"
#include "llvm/IR/CFG.h"		#include "llvm/IR/CFG.h"
#include "llvm/IR/Constants.h"		#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"		#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Function.h"		#include "llvm/IR/Function.h"
#include "llvm/IR/GetElementPtrTypeIterator.h"		#include "llvm/IR/GetElementPtrTypeIterator.h"
▲ Show 20 Lines • Show All 288 Lines • ▼ Show 20 Lines	ScalarConversionOpts()
: TreatBooleanAsSigned(false),		: TreatBooleanAsSigned(false),
EmitImplicitIntegerTruncationChecks(false) {}		EmitImplicitIntegerTruncationChecks(false) {}
};		};
Value *		Value *
EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy,		EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy,
SourceLocation Loc,		SourceLocation Loc,
ScalarConversionOpts Opts = ScalarConversionOpts());		ScalarConversionOpts Opts = ScalarConversionOpts());

		Value EmitFixedPointConversion(Value Src, QualType SrcTy, QualType DstTy,
		SourceLocation Loc);

/// Emit a conversion from the specified complex type to the specified		/// Emit a conversion from the specified complex type to the specified
/// destination type, where the destination type is an LLVM scalar type.		/// destination type, where the destination type is an LLVM scalar type.
Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,		Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
QualType SrcTy, QualType DstTy,		QualType SrcTy, QualType DstTy,
SourceLocation Loc);		SourceLocation Loc);

/// EmitNullValue - Emit a value that corresponds to null for the given type.		/// EmitNullValue - Emit a value that corresponds to null for the given type.
Value *EmitNullValue(QualType Ty);		Value *EmitNullValue(QualType Ty);
▲ Show 20 Lines • Show All 668 Lines • ▼ Show 20 Lines
}		}

/// Emit a conversion from the specified type to the specified destination type,		/// Emit a conversion from the specified type to the specified destination type,
/// both of which are LLVM scalar types.		/// both of which are LLVM scalar types.
Value ScalarExprEmitter::EmitScalarConversion(Value Src, QualType SrcType,		Value ScalarExprEmitter::EmitScalarConversion(Value Src, QualType SrcType,
QualType DstType,		QualType DstType,
SourceLocation Loc,		SourceLocation Loc,
ScalarConversionOpts Opts) {		ScalarConversionOpts Opts) {
		assert(!SrcType->isFixedPointType() && !DstType->isFixedPointType() &&
		"Use the ScalarExprEmitter::EmitFixedPoint family functions for "
		"handling conversions involving fixed point types.");

QualType NoncanonicalSrcType = SrcType;		QualType NoncanonicalSrcType = SrcType;
QualType NoncanonicalDstType = DstType;		QualType NoncanonicalDstType = DstType;

SrcType = CGF.getContext().getCanonicalType(SrcType);		SrcType = CGF.getContext().getCanonicalType(SrcType);
DstType = CGF.getContext().getCanonicalType(DstType);		DstType = CGF.getContext().getCanonicalType(DstType);
if (SrcType == DstType) return Src;		if (SrcType == DstType) return Src;

if (DstType->isVoidType()) return nullptr;		if (DstType->isVoidType()) return nullptr;
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Lines	Value ScalarExprEmitter::EmitScalarConversion(Value Src, QualType SrcType,

if (Opts.EmitImplicitIntegerTruncationChecks)		if (Opts.EmitImplicitIntegerTruncationChecks)
EmitIntegerTruncationCheck(Src, NoncanonicalSrcType, Res,		EmitIntegerTruncationCheck(Src, NoncanonicalSrcType, Res,
NoncanonicalDstType, Loc);		NoncanonicalDstType, Loc);

return Res;		return Res;
}		}

		Value ScalarExprEmitter::EmitFixedPointConversion(Value Src, QualType SrcTy,
		QualType DstTy,
		SourceLocation Loc) {
		using llvm::APInt;
		using llvm::ConstantInt;
		using llvm::Value;

		assert(SrcTy->isFixedPointType());
		assert(DstTy->isFixedPointType());

		FixedPointSemantics SrcFPSema =
		CGF.getContext().getFixedPointSemantics(SrcTy);
		FixedPointSemantics DstFPSema =
		CGF.getContext().getFixedPointSemantics(DstTy);
		unsigned SrcWidth = SrcFPSema.getWidth();
		unsigned DstWidth = DstFPSema.getWidth();
		unsigned SrcScale = SrcFPSema.getScale();
		unsigned DstScale = DstFPSema.getScale();
		bool IsSigned = SrcFPSema.isSigned();

		Value *Result = Src;
		unsigned ResultWidth = SrcWidth;

		if (!DstFPSema.isSaturated()) {
		// Downscale
		if (DstScale < SrcScale) {
		if (IsSigned)
		Result = Builder.CreateAShr(Result, SrcScale - DstScale);
		else
		Result = Builder.CreateLShr(Result, SrcScale - DstScale);
		}

		// Resize
		llvm::Type *DstIntTy = Builder.getIntNTy(DstWidth);
		if (IsSigned)
		Result = Builder.CreateSExtOrTrunc(Result, DstIntTy);
		else
		Result = Builder.CreateZExtOrTrunc(Result, DstIntTy);

		// Upscale
		if (DstScale > SrcScale)
		Result = Builder.CreateShl(Result, DstScale - SrcScale);
		} else {
		if (DstScale > SrcScale) {
		// Need to extend first before scaling up
		ResultWidth = SrcWidth + DstScale - SrcScale;
		llvm::Type *UpscaledTy = Builder.getIntNTy(ResultWidth);

		if (IsSigned)
		Result = Builder.CreateSExt(Result, UpscaledTy);
		else
		Result = Builder.CreateZExt(Result, UpscaledTy);

		Result = Builder.CreateShl(Result, DstScale - SrcScale);
		} else if (DstScale < SrcScale) {
		if (IsSigned)
		Result = Builder.CreateAShr(Result, SrcScale - DstScale);
		else
		Result = Builder.CreateLShr(Result, SrcScale - DstScale);
		}

		if (DstFPSema.getIntegralBits() < SrcFPSema.getIntegralBits()) {
		auto Max = ConstantInt::get(
		CGF.getLLVMContext(),
		APFixedPoint::getMax(DstFPSema).getValue().extOrTrunc(ResultWidth));
		Value *TooHigh = IsSigned ? Builder.CreateICmpSGT(Result, Max)
		: Builder.CreateICmpUGT(Result, Max);
		Result = Builder.CreateSelect(TooHigh, Max, Result);

		if (IsSigned) {
		// Cannot overflow min to dest type is src is unsigned since all fixed
		// point types can cover the unsigned min of 0.
		auto Min = ConstantInt::get(
		CGF.getLLVMContext(),
		APFixedPoint::getMin(DstFPSema).getValue().extOrTrunc(ResultWidth));
		Value *TooLow = Builder.CreateICmpSLT(Result, Min);
		Result = Builder.CreateSelect(TooLow, Min, Result);
		}
		} else if (IsSigned && !DstFPSema.isSigned()) {
		llvm::Type *ResultTy = Builder.getIntNTy(ResultWidth);
		Value *Zero = ConstantInt::getNullValue(ResultTy);
		Value *LTZero = Builder.CreateICmpSLT(Result, Zero);
		Result = Builder.CreateSelect(LTZero, Zero, Result);
		}

		// Final resizing to dst width
		llvm::Type *DstIntTy = Builder.getIntNTy(DstWidth);
		if (IsSigned)
		Result = Builder.CreateSExtOrTrunc(Result, DstIntTy);
		else
		Result = Builder.CreateZExtOrTrunc(Result, DstIntTy);
		}
		return Result;
		}

/// Emit a conversion from the specified complex type to the specified		/// Emit a conversion from the specified complex type to the specified
/// destination type, where the destination type is an LLVM scalar type.		/// destination type, where the destination type is an LLVM scalar type.
Value *ScalarExprEmitter::EmitComplexToScalarConversion(		Value *ScalarExprEmitter::EmitComplexToScalarConversion(
CodeGenFunction::ComplexPairTy Src, QualType SrcTy, QualType DstTy,		CodeGenFunction::ComplexPairTy Src, QualType SrcTy, QualType DstTy,
SourceLocation Loc) {		SourceLocation Loc) {
// Get the source element type.		// Get the source element type.
SrcTy = SrcTy->castAs<ComplexType>()->getElementType();		SrcTy = SrcTy->castAs<ComplexType>()->getElementType();

▲ Show 20 Lines • Show All 674 Lines • ▼ Show 20 Lines	Value ScalarExprEmitter::VisitCastExpr(CastExpr CE) {
case CK_VectorSplat: {		case CK_VectorSplat: {
llvm::Type *DstTy = ConvertType(DestTy);		llvm::Type *DstTy = ConvertType(DestTy);
Value Elt = Visit(const_cast<Expr>(E));		Value Elt = Visit(const_cast<Expr>(E));
// Splat the element across to all elements		// Splat the element across to all elements
unsigned NumElements = DstTy->getVectorNumElements();		unsigned NumElements = DstTy->getVectorNumElements();
return Builder.CreateVectorSplat(NumElements, Elt, "splat");		return Builder.CreateVectorSplat(NumElements, Elt, "splat");
}		}

		case CK_FixedPointCast:
		return EmitFixedPointConversion(Visit(E), E->getType(), DestTy,
		CE->getExprLoc());

case CK_IntegralCast: {		case CK_IntegralCast: {
ScalarConversionOpts Opts;		ScalarConversionOpts Opts;
if (CGF.SanOpts.hasOneOf(SanitizerKind::ImplicitIntegerTruncation)) {		if (CGF.SanOpts.hasOneOf(SanitizerKind::ImplicitIntegerTruncation)) {
if (auto *ICE = dyn_cast<ImplicitCastExpr>(CE))		if (auto *ICE = dyn_cast<ImplicitCastExpr>(CE))
Opts.EmitImplicitIntegerTruncationChecks = !ICE->isPartOfExplicitCast();		Opts.EmitImplicitIntegerTruncationChecks = !ICE->isPartOfExplicitCast();
}		}
return EmitScalarConversion(Visit(E), E->getType(), DestTy,		return EmitScalarConversion(Visit(E), E->getType(), DestTy,
CE->getExprLoc(), Opts);		CE->getExprLoc(), Opts);
▲ Show 20 Lines • Show All 2,316 Lines • Show Last 20 Lines