8e4f0d8614
This patch adds all bits required to implement builtin function calls to ClangIR. It doesn't actually implement any of the builtins except those that fold to a constant ahead of CodeGen (`__builtin_is_constant_evaluated()` being one example).
56 lines
2.3 KiB
C++
56 lines
2.3 KiB
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 contains code to emit Builtin calls as CIR or a function call to be
|
|
// later resolved.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "CIRGenCall.h"
|
|
#include "CIRGenFunction.h"
|
|
#include "CIRGenModule.h"
|
|
#include "CIRGenValue.h"
|
|
#include "mlir/IR/BuiltinAttributes.h"
|
|
#include "mlir/IR/Value.h"
|
|
#include "mlir/Support/LLVM.h"
|
|
#include "clang/AST/Expr.h"
|
|
#include "clang/AST/GlobalDecl.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
using namespace clang;
|
|
using namespace clang::CIRGen;
|
|
|
|
RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl &gd, unsigned builtinID,
|
|
const CallExpr *e,
|
|
ReturnValueSlot returnValue) {
|
|
// See if we can constant fold this builtin. If so, don't emit it at all.
|
|
// TODO: Extend this handling to all builtin calls that we can constant-fold.
|
|
Expr::EvalResult result;
|
|
if (e->isPRValue() && e->EvaluateAsRValue(result, cgm.getASTContext()) &&
|
|
!result.hasSideEffects()) {
|
|
if (result.Val.isInt()) {
|
|
return RValue::get(builder.getConstInt(getLoc(e->getSourceRange()),
|
|
result.Val.getInt()));
|
|
}
|
|
if (result.Val.isFloat()) {
|
|
// Note: we are using result type of CallExpr to determine the type of
|
|
// the constant. Classic codegen uses the result value to determine the
|
|
// type. We feel it should be Ok to use expression type because it is
|
|
// hard to imagine a builtin function evaluates to a value that
|
|
// over/underflows its own defined type.
|
|
mlir::Type type = convertType(e->getType());
|
|
return RValue::get(builder.getConstFP(getLoc(e->getExprLoc()), type,
|
|
result.Val.getFloat()));
|
|
}
|
|
}
|
|
|
|
mlir::Location loc = getLoc(e->getExprLoc());
|
|
cgm.errorNYI(loc, "non constant foldable builtin calls");
|
|
return getUndefRValue(e->getType());
|
|
}
|