Differential D41760 Diff 128726 lib/CodeGen/CGBuiltin.cpp

Changeset View

Standalone View

lib/CodeGen/CGBuiltin.cpp

This file is larger than 256 KB, so syntax highlighting is disabled by default.

Show First 20 Lines • Show All 766 Lines • ▼ Show 20 Lines	for (const auto &Item : Layout.Items) {
++I;		++I;
}		}

FinishFunction();		FinishFunction();

return Fn;		return Fn;
}		}

		/// @brief Utility to insert expansion for __builtin_load_no_speculate for
		/// targets than don't support llvm.nospeculateload. Expand
		/// __builtin_load_no_speculate(ptr, lower, upper, failval, cmpptr)
		/// to a call to:
		/// inline TYP __builtin_load_no_speculate
		/// (const volatile TYP *ptr,
		/// const volatile void *lower,
		/// const volatile void *upper,
		/// TYP failval,
		/// const volatile void *cmpptr)
		/// {
		/// TYP result;
		/// if (cmpptr >= lower && cmpptr < upper)
		/// result = *ptr;
		/// else
		/// result = failval;
		/// return result;
		/// }
		///
		static Value MakeBuiltinLoadNoSpeculate(CodeGenFunction &CGF, Value Ptr,
		Value LowerBound, Value UpperBound,
		Value FailVal, Value CmpPtr,
		clang::QualType ResultType) {
		Value *LowerBoundCmp = nullptr;
		Value *UpperBoundCmp = nullptr;
		Value *Condition = nullptr;
		if (LowerBound)
		LowerBoundCmp = CGF.Builder.CreateICmp(llvm::CmpInst::ICMP_UGE, CmpPtr,
		LowerBound, "cmplower");
		if (UpperBound)
		UpperBoundCmp = CGF.Builder.CreateICmp(llvm::CmpInst::ICMP_ULT, CmpPtr,
		UpperBound, "cmpupper");
		if (LowerBoundCmp && UpperBoundCmp)
		Condition = CGF.Builder.CreateAnd(LowerBoundCmp, UpperBoundCmp, "cond");
		else if (LowerBoundCmp)
		Condition = LowerBoundCmp;
		else {
		assert(UpperBoundCmp != nullptr);
		Condition = UpperBoundCmp;
		}

		llvm::BasicBlock *InitialBB = CGF.Builder.GetInsertBlock();
		llvm::BasicBlock *InBoundsBB =
		CGF.createBasicBlock("inBoundsBB", CGF.CurFn, InitialBB->getNextNode());
		llvm::BasicBlock *NextBB =
		CGF.createBasicBlock("loadnospecJoinBB", CGF.CurFn,
		InBoundsBB->getNextNode());

		CGF.Builder.CreateCondBr(Condition, InBoundsBB, NextBB);

		CGF.Builder.SetInsertPoint(InBoundsBB);
		Address PtrAddress(Ptr,
		CGF.getContext().getTypeAlignInChars(ResultType));
		Value *PtrDeref =
		CGF.Builder.CreateLoad(PtrAddress, true /IsVolatile/, "PtrDeref");
		CGF.Builder.CreateBr(NextBB);

		CGF.Builder.SetInsertPoint(NextBB);
		llvm::PHINode *Phi =
		CGF.Builder.CreatePHI(FailVal->getType(), 2, "load_no_speculate_res");
		Phi->addIncoming(PtrDeref, InBoundsBB);
		Phi->addIncoming(FailVal, InitialBB);

		return Phi;
		}


RValue CodeGenFunction::emitBuiltinOSLogFormat(const CallExpr &E) {		RValue CodeGenFunction::emitBuiltinOSLogFormat(const CallExpr &E) {
assert(E.getNumArgs() >= 2 &&		assert(E.getNumArgs() >= 2 &&
"__builtin_os_log_format takes at least 2 arguments");		"__builtin_os_log_format takes at least 2 arguments");
ASTContext &Ctx = getContext();		ASTContext &Ctx = getContext();
analyze_os_log::OSLogBufferLayout Layout;		analyze_os_log::OSLogBufferLayout Layout;
analyze_os_log::computeOSLogBufferLayout(Ctx, &E, Layout);		analyze_os_log::computeOSLogBufferLayout(Ctx, &E, Layout);
Address BufAddr = EmitPointerWithAlignment(E.getArg(0));		Address BufAddr = EmitPointerWithAlignment(E.getArg(0));
llvm::SmallVector<llvm::Value *, 4> RetainableOperands;		llvm::SmallVector<llvm::Value *, 4> RetainableOperands;
▲ Show 20 Lines • Show All 2,440 Lines • ▼ Show 20 Lines	case Builtin::BI__builtin_ms_va_copy: {
DestAddr = Address(Builder.CreateBitCast(DestAddr.getPointer(), BPP, "cp"),		DestAddr = Address(Builder.CreateBitCast(DestAddr.getPointer(), BPP, "cp"),
DestAddr.getAlignment());		DestAddr.getAlignment());
SrcAddr = Address(Builder.CreateBitCast(SrcAddr.getPointer(), BPP, "ap"),		SrcAddr = Address(Builder.CreateBitCast(SrcAddr.getPointer(), BPP, "ap"),
SrcAddr.getAlignment());		SrcAddr.getAlignment());

Value *ArgPtr = Builder.CreateLoad(SrcAddr, "ap.val");		Value *ArgPtr = Builder.CreateLoad(SrcAddr, "ap.val");
return RValue::get(Builder.CreateStore(ArgPtr, DestAddr));		return RValue::get(Builder.CreateStore(ArgPtr, DestAddr));
}		}
		case Builtin::BI__builtin_load_no_speculate: {
		Value *Ptr = EmitScalarExpr(E->getArg(0));

		bool LowerBoundNull =
		E->getArg(1)->IgnoreParenCasts()->isNullPointerConstant(
		getContext(), Expr::NPC_ValueDependentIsNotNull);
		bool UpperBoundNull =
		E->getArg(2)->IgnoreParenCasts()->isNullPointerConstant(
		getContext(), Expr::NPC_ValueDependentIsNotNull);

		assert((!LowerBoundNull \|\| !UpperBoundNull) &&
		"at least one bound must be non-null!");

		Value *LowerBound = LowerBoundNull ? nullptr : EmitScalarExpr(E->getArg(1));
		Value *UpperBound = UpperBoundNull ? nullptr : EmitScalarExpr(E->getArg(2));

		llvm::Type *T = ConvertType(E->getType());
		assert((isa<llvm::IntegerType>(T) \|\| isa<llvm::PointerType>(T)) &&
		"unsupported type");

		if (isa<llvm::IntegerType>(T)) {
		CharUnits LoadSize = getContext().getTypeSizeInChars(E->getType());
		T = llvm::IntegerType::get(getLLVMContext(), LoadSize.getQuantity() * 8);
		Ptr = Builder.CreateBitCast(Ptr, T->getPointerTo());
		}

		// If failval is omitted, zero of the appropriate type will be used.
		Value *FailVal = nullptr;
		if (E->getNumArgs() >= 4) {
		FailVal = EmitScalarExpr(E->getArg(3));
		if (T != FailVal->getType()) {
		assert(T->getScalarSizeInBits() >
		FailVal->getType()->getScalarSizeInBits());
		FailVal = Builder.CreateZExt(FailVal, T);
		}
		} else {
		if (isa<llvm::IntegerType>(T)) {
		FailVal = llvm::ConstantInt::get(T, 0);
		} else if (isa<llvm::PointerType>(T)) {
		FailVal = llvm::ConstantPointerNull::get(cast<llvm::PointerType>(T));
		}
		}
		assert(FailVal && "default FailVal not set");

		// If cmpptr is omitted, ptr will be used.
		Value *CmpPtr = (E->getNumArgs() >= 5) ? EmitScalarExpr(E->getArg(4)) : Ptr;
		CmpPtr = Builder.CreateBitCast(CmpPtr, Builder.getInt8PtrTy());

		if (!getContext().getTargetInfo().hasBuiltinLoadNoSpeculate())
		return RValue::get(MakeBuiltinLoadNoSpeculate(
		*this, Ptr, LowerBound, UpperBound, FailVal, CmpPtr,
		E->getType()));
		else if (LowerBoundNull)
		return RValue::get(Builder.CreateCall(
		CGM.getIntrinsic(Intrinsic::nospeculateload_nolower, T),
		{Ptr, UpperBound, FailVal, CmpPtr}));
		else if (UpperBoundNull)
		return RValue::get(Builder.CreateCall(
		CGM.getIntrinsic(Intrinsic::nospeculateload_noupper, T),
		{Ptr, LowerBound, FailVal, CmpPtr}));
		else
		return RValue::get(
		Builder.CreateCall(CGM.getIntrinsic(Intrinsic::nospeculateload, T),
		{Ptr, LowerBound, UpperBound, FailVal, CmpPtr}));
		}
}		}

// If this is an alias for a lib function (e.g. __builtin_sin), emit		// If this is an alias for a lib function (e.g. __builtin_sin), emit
// the call using the normal call path, but using the unmangled		// the call using the normal call path, but using the unmangled
// version of the function name.		// version of the function name.
if (getContext().BuiltinInfo.isLibFunction(BuiltinID))		if (getContext().BuiltinInfo.isLibFunction(BuiltinID))
return emitLibraryCall(*this, FD, E,		return emitLibraryCall(*this, FD, E,
CGM.getBuiltinLibFunction(FD, BuiltinID));		CGM.getBuiltinLibFunction(FD, BuiltinID));
▲ Show 20 Lines • Show All 7,079 Lines • Show Last 20 Lines