bool FlattenCFGTransformer::HandleAnyFunctionDecl(Decl *D){
DPRINT("enter FuncDecl");
FunctionDecl *fd = NULL;
if(FunctionTemplateDecl *td = dyn_cast<FunctionTemplateDecl>(D)) { // function template
fd = td->getTemplatedDecl();
} else if(FunctionDecl *td = dyn_cast<FunctionDecl>(D)) { // function, c++ method
fd = td;
} else {
DPRINT("unknown FunctionDecl type: %s %x", D->getDeclKindName(),(unsigned int)D);
return false;
}
assert(fd && "get FunctionDecl failed");
//TODO
Stmt *oldBody = fd->getBody();
this->renamer->HandleDecl(fd);
this->preTranser->HandleDecl(fd);
this->dclMover->HandelDecl(fd);
this->flat->HandleDecl(fd);
// refresh RewriteBuffer
Rewriter &rw = resMgr.getRewriter();
rw.ReplaceStmt(oldBody, fd->getBody());
return true;
}
void ReturnSynthesizer::Transform() {
if (!getTransaction()->getCompilationOpts().ResultEvaluation)
return;
FunctionDecl* FD = getTransaction()->getWrapperFD();
int foundAtPos = -1;
Expr* lastExpr = utils::Analyze::GetOrCreateLastExpr(FD, &foundAtPos,
/*omitDS*/false,
m_Sema);
if (lastExpr) {
QualType RetTy = lastExpr->getType();
if (!RetTy->isVoidType() && RetTy.isTriviallyCopyableType(*m_Context)) {
// Change the void function's return type
// We can't PushDeclContext, because we don't have scope.
Sema::ContextRAII pushedDC(*m_Sema, FD);
FunctionProtoType::ExtProtoInfo EPI;
QualType FnTy
= m_Context->getFunctionType(RetTy, llvm::ArrayRef<QualType>(), EPI);
FD->setType(FnTy);
CompoundStmt* CS = cast<CompoundStmt>(FD->getBody());
assert(CS && "Missing body?");
// Change it to a return stmt (Avoid dealloc/alloc of all el.)
*(CS->body_begin() + foundAtPos)
= m_Sema->ActOnReturnStmt(lastExpr->getExprLoc(),
lastExpr).take();
}
} else if (foundAtPos >= 0) {
// check for non-void return statement
CompoundStmt* CS = cast<CompoundStmt>(FD->getBody());
Stmt* CSS = *(CS->body_begin() + foundAtPos);
if (ReturnStmt* RS = dyn_cast<ReturnStmt>(CSS)) {
if (Expr* RetV = RS->getRetValue()) {
QualType RetTy = RetV->getType();
// Any return statement will have been "healed" by Sema
// to correspond to the original void return type of the
// wrapper, using a ImplicitCastExpr 'void' <ToVoid>.
// Remove that.
if (RetTy->isVoidType()) {
ImplicitCastExpr* VoidCast = dyn_cast<ImplicitCastExpr>(RetV);
if (VoidCast) {
RS->setRetValue(VoidCast->getSubExpr());
RetTy = VoidCast->getSubExpr()->getType();
}
}
if (!RetTy->isVoidType()
&& RetTy.isTriviallyCopyableType(*m_Context)) {
Sema::ContextRAII pushedDC(*m_Sema, FD);
FunctionProtoType::ExtProtoInfo EPI;
QualType FnTy
= m_Context->getFunctionType(RetTy, llvm::ArrayRef<QualType>(),
EPI);
FD->setType(FnTy);
} // not returning void
} // have return value
} // is a return statement
} // have a statement
}
bool Utils::isInitializedExternally(clang::VarDecl *varDecl)
{
if (!varDecl)
return false;
DeclContext *context = varDecl->getDeclContext();
FunctionDecl *fDecl = context ? dyn_cast<FunctionDecl>(context) : nullptr;
Stmt *body = fDecl ? fDecl->getBody() : nullptr;
if (!body)
return false;
vector<DeclStmt*> declStmts;
HierarchyUtils::getChilds<DeclStmt>(body, declStmts);
for (DeclStmt *declStmt : declStmts) {
if (referencesVarDecl(declStmt, varDecl)) {
vector<DeclRefExpr*> declRefs;
HierarchyUtils::getChilds<DeclRefExpr>(declStmt, declRefs);
if (!declRefs.empty()) {
return true;
}
vector<CallExpr*> callExprs;
HierarchyUtils::getChilds<CallExpr>(declStmt, callExprs);
if (!callExprs.empty()) {
return true;
}
}
}
return false;
}
unsigned RefFinder::find() {
// TODO search more places (types, inits, etc)
// search Function bodies
for (unsigned i=0; i<ast.numFunctions(); i++) {
FunctionDecl* F = ast.getFunction(i);
searchCompoundStmt(F->getBody());
}
return locs.size();
}
void NullDerefProtectionTransformer::Transform() {
FunctionDecl* FD = getTransaction()->getWrapperFD();
if (!FD)
return;
CompoundStmt* CS = dyn_cast<CompoundStmt>(FD->getBody());
assert(CS && "Function body not a CompundStmt?");
IfStmtInjector injector((*m_Sema));
CompoundStmt* newCS = injector.Inject(CS);
FD->setBody(newCS);
}
virtual void run(const MatchFinder::MatchResult &results)
{
FunctionDecl *functionDecl = (FunctionDecl *)
results.Nodes.getNodeAs<FunctionDecl>("functionDecl");
if (functionDecl)
{
StmtDepthMetric stmtDepthMetric;
EXPECT_EQ(_depth, stmtDepthMetric.depth(functionDecl->getBody()));
}
else
{
FAIL();
}
}
virtual void run(const MatchFinder::MatchResult &results)
{
FunctionDecl *functionDecl = (FunctionDecl *)
results.Nodes.getNodeAs<FunctionDecl>("functionDecl");
if (functionDecl)
{
NcssMetric ncssMetric;
EXPECT_EQ(_ncss, ncssMetric.ncss(functionDecl->getBody()));
}
else
{
FAIL();
}
}
virtual void run(const MatchFinder::MatchResult &results)
{
FunctionDecl *functionDecl = (FunctionDecl *)
results.Nodes.getNodeAs<FunctionDecl>("functionDecl");
if (functionDecl)
{
NPathComplexityMetric nPathMetric;
EXPECT_EQ(_nPath, nPathMetric.nPath(functionDecl->getBody()));
}
else
{
FAIL();
}
}
ASTTransformer::Result
NullDerefProtectionTransformer::Transform(clang::Decl* D) {
FunctionDecl* FD = dyn_cast<FunctionDecl>(D);
if (!FD || FD->isFromASTFile())
return Result(D, true);
CompoundStmt* CS = dyn_cast_or_null<CompoundStmt>(FD->getBody());
if (!CS)
return Result(D, true);
PointerCheckInjector injector(*m_Sema);
injector.Visit(CS);
return Result(FD, true);
}
void FunctionArgsByRef::VisitDecl(Decl *decl)
{
FunctionDecl *functionDecl = dyn_cast<FunctionDecl>(decl);
if (functionDecl == nullptr || !functionDecl->hasBody() || shouldIgnoreFunction(functionDecl->getNameAsString())
|| !functionDecl->isThisDeclarationADefinition()) return;
Stmt *body = functionDecl->getBody();
for (auto it = functionDecl->param_begin(), end = functionDecl->param_end(); it != end; ++it) {
const ParmVarDecl *param = *it;
QualType paramQt = param->getType();
const Type *paramType = paramQt.getTypePtrOrNull();
if (paramType == nullptr || paramType->isDependentType())
continue;
const int size_of_T = m_ci.getASTContext().getTypeSize(paramQt) / 8;
const bool isSmall = size_of_T <= 16; // TODO: What about arm ?
CXXRecordDecl *recordDecl = paramType->getAsCXXRecordDecl();
const bool isUserNonTrivial = recordDecl && (recordDecl->hasUserDeclaredCopyConstructor() || recordDecl->hasUserDeclaredDestructor());
const bool isReference = paramType->isLValueReferenceType();
const bool isConst = paramQt.isConstQualified();
if (recordDecl && shouldIgnoreClass(recordDecl->getQualifiedNameAsString()))
continue;
std::string error;
if (isConst && !isReference) {
if (!isSmall) {
error += warningMsgForSmallType(size_of_T, paramQt.getAsString());
} else if (isUserNonTrivial) {
error += "Missing reference on non-trivial type " + recordDecl->getQualifiedNameAsString();
}
} else if (isConst && isReference && !isUserNonTrivial && isSmall) {
//error += "Don't use by-ref on small trivial type";
} else if (!isConst && !isReference && (!isSmall || isUserNonTrivial)) {
if (Utils::containsNonConstMemberCall(body, param) || Utils::containsCallByRef(body, param))
continue;
if (!isSmall) {
error += warningMsgForSmallType(size_of_T, paramQt.getAsString());
} else if (isUserNonTrivial) {
error += "Missing reference on non-trivial type " + recordDecl->getQualifiedNameAsString();
}
}
if (!error.empty()) {
emitWarning(param->getLocStart(), error.c_str());
}
}
}
void ValueExtractionSynthesizer::Transform() {
const CompilationOptions& CO = getTransaction()->getCompilationOpts();
// If we do not evaluate the result, or printing out the result return.
if (!(CO.ResultEvaluation || CO.ValuePrinting))
return;
FunctionDecl* FD = getTransaction()->getWrapperFD();
int foundAtPos = -1;
Expr* lastExpr = utils::Analyze::GetOrCreateLastExpr(FD, &foundAtPos,
/*omitDS*/false,
m_Sema);
if (foundAtPos < 0)
return;
typedef llvm::SmallVector<Stmt**, 4> StmtIters;
StmtIters returnStmts;
ReturnStmtCollector collector(returnStmts);
CompoundStmt* CS = cast<CompoundStmt>(FD->getBody());
collector.VisitStmt(CS);
if (isa<Expr>(*(CS->body_begin() + foundAtPos)))
returnStmts.push_back(CS->body_begin() + foundAtPos);
// We want to support cases such as:
// gCling->evaluate("if() return 'A' else return 12", V), that puts in V,
// either A or 12.
// In this case the void wrapper is compiled with the stmts returning
// values. Sema would cast them to void, but the code will still be
// executed. For example:
// int g(); void f () { return g(); } will still call g().
//
for (StmtIters::iterator I = returnStmts.begin(), E = returnStmts.end();
I != E; ++I) {
ReturnStmt* RS = dyn_cast<ReturnStmt>(**I);
if (RS) {
// When we are handling a return stmt, the last expression must be the
// return stmt value. Ignore the calculation of the lastStmt because it
// might be wrong, in cases where the return is not in the end of the
// function.
lastExpr = RS->getRetValue();
if (lastExpr) {
assert (lastExpr->getType()->isVoidType() && "Must be void type.");
// Any return statement will have been "healed" by Sema
// to correspond to the original void return type of the
// wrapper, using a ImplicitCastExpr 'void' <ToVoid>.
// Remove that.
if (ImplicitCastExpr* VoidCast
= dyn_cast<ImplicitCastExpr>(lastExpr)) {
lastExpr = VoidCast->getSubExpr();
}
}
// if no value assume void
else {
// We can't PushDeclContext, because we don't have scope.
Sema::ContextRAII pushedDC(*m_Sema, FD);
RS->setRetValue(SynthesizeSVRInit(0));
}
}
else
lastExpr = cast<Expr>(**I);
if (lastExpr) {
QualType lastExprTy = lastExpr->getType();
// May happen on auto types which resolve to dependent.
if (lastExprTy->isDependentType())
continue;
// Set up lastExpr properly.
// Change the void function's return type
// We can't PushDeclContext, because we don't have scope.
Sema::ContextRAII pushedDC(*m_Sema, FD);
if (lastExprTy->isFunctionType()) {
// A return type of function needs to be converted to
// pointer to function.
lastExprTy = m_Context->getPointerType(lastExprTy);
lastExpr = m_Sema->ImpCastExprToType(lastExpr, lastExprTy,
CK_FunctionToPointerDecay,
VK_RValue).take();
}
//
// Here we don't want to depend on the JIT runFunction, because of its
// limitations, when it comes to return value handling. There it is
// not clear who provides the storage and who cleans it up in a
// platform independent way.
//
// Depending on the type we need to synthesize a call to cling:
// 0) void : set the value's type to void;
// 1) enum, integral, float, double, referece, pointer types :
// call to cling::internal::setValueNoAlloc(...);
// 2) object type (alloc on the stack) :
// cling::internal::setValueWithAlloc
// 2.1) constant arrays:
// call to cling::runtime::internal::copyArray(...)
//
// We need to synthesize later:
// Wrapper has signature: void w(cling::Value SVR)
// case 1):
// setValueNoAlloc(gCling, &SVR, lastExprTy, lastExpr())
// case 2):
// new (setValueWithAlloc(gCling, &SVR, lastExprTy)) (lastExpr)
// case 2.1):
// copyArray(src, placement, size)
Expr* SVRInit = SynthesizeSVRInit(lastExpr);
// if we had return stmt update to execute the SVR init, even if the
// wrapper returns void.
if (RS) {
if (ImplicitCastExpr* VoidCast
= dyn_cast<ImplicitCastExpr>(RS->getRetValue()))
VoidCast->setSubExpr(SVRInit);
}
else
**I = SVRInit;
}
}
}
void process(FunctionDecl* fd) {
this->fd = fd;
Visit(fd->getBody());
}
bool DeclExtractor::ExtractDecl(Decl* D) {
FunctionDecl* FD = dyn_cast<FunctionDecl>(D);
if (FD) {
if (FD->getNameAsString().find("__cling_Un1Qu3"))
return true;
llvm::SmallVector<NamedDecl*, 4> TouchedDecls;
CompoundStmt* CS = dyn_cast<CompoundStmt>(FD->getBody());
assert(CS && "Function body not a CompoundStmt?");
DeclContext* DC = FD->getTranslationUnitDecl();
Scope* TUScope = m_Sema->TUScope;
assert(TUScope == m_Sema->getScopeForContext(DC) && "TU scope from DC?");
llvm::SmallVector<Stmt*, 4> Stmts;
for (CompoundStmt::body_iterator I = CS->body_begin(), EI = CS->body_end();
I != EI; ++I) {
DeclStmt* DS = dyn_cast<DeclStmt>(*I);
if (!DS) {
Stmts.push_back(*I);
continue;
}
for (DeclStmt::decl_iterator J = DS->decl_begin();
J != DS->decl_end(); ++J) {
NamedDecl* ND = dyn_cast<NamedDecl>(*J);
if (ND) {
DeclContext* OldDC = ND->getDeclContext();
// Make sure the decl is not found at its old possition
OldDC->removeDecl(ND);
if (Scope* S = m_Sema->getScopeForContext(OldDC)) {
S->RemoveDecl(ND);
m_Sema->IdResolver.RemoveDecl(ND);
}
if (ND->getDeclContext() == ND->getLexicalDeclContext())
ND->setLexicalDeclContext(DC);
else
assert("Not implemented: Decl with different lexical context");
ND->setDeclContext(DC);
if (VarDecl* VD = dyn_cast<VarDecl>(ND)) {
VD->setStorageClass(SC_None);
VD->setStorageClassAsWritten(SC_None);
// if we want to print the result of the initializer of int i = 5
// or the default initializer int i
if (I+1 == EI || !isa<NullStmt>(*(I+1))) {
QualType VDTy = VD->getType().getNonReferenceType();
Expr* DRE = m_Sema->BuildDeclRefExpr(VD, VDTy,VK_LValue,
SourceLocation()
).take();
Stmts.push_back(DRE);
}
}
// force recalc of the linkage (to external)
ND->ClearLinkageCache();
TouchedDecls.push_back(ND);
}
}
}
bool hasNoErrors = !CheckForClashingNames(TouchedDecls, DC, TUScope);
if (hasNoErrors) {
for (size_t i = 0; i < TouchedDecls.size(); ++i) {
m_Sema->PushOnScopeChains(TouchedDecls[i],
m_Sema->getScopeForContext(DC),
/*AddCurContext*/!isa<UsingDirectiveDecl>(TouchedDecls[i]));
// The transparent DeclContexts (eg. scopeless enum) doesn't have
// scopes. While extracting their contents we need to update the
// lookup tables and telling them to pick up the new possitions
// in the AST.
if (DeclContext* InnerDC = dyn_cast<DeclContext>(TouchedDecls[i])) {
if (InnerDC->isTransparentContext()) {
// We can't PushDeclContext, because we don't have scope.
Sema::ContextRAII pushedDC(*m_Sema, InnerDC);
for(DeclContext::decl_iterator DI = InnerDC->decls_begin(),
DE = InnerDC->decls_end(); DI != DE ; ++DI) {
if (NamedDecl* ND = dyn_cast<NamedDecl>(*DI))
InnerDC->makeDeclVisibleInContext(ND);
}
}
}
// Append the new top level decl to the current transaction.
getTransaction()->appendUnique(DeclGroupRef(TouchedDecls[i]));
}
}
CS->setStmts(*m_Context, Stmts.data(), Stmts.size());
// Put the wrapper after its declarations. (Nice when AST dumping)
DC->removeDecl(FD);
DC->addDecl(FD);
return hasNoErrors;
}
return true;
}
