C++ (Cpp) ASTContext::Deallocate Examples

Example #1

File: Stmt.cpp Project: elfprince13/clang

void GCCAsmStmt::setOutputsAndInputsAndClobbers(const ASTContext &C,
                                                IdentifierInfo **Names,
                                                StringLiteral **Constraints,
                                                Stmt **Exprs,
                                                unsigned NumOutputs,
                                                unsigned NumInputs,
                                                StringLiteral **Clobbers,
                                                unsigned NumClobbers) {
  this->NumOutputs = NumOutputs;
  this->NumInputs = NumInputs;
  this->NumClobbers = NumClobbers;

  unsigned NumExprs = NumOutputs + NumInputs;

  C.Deallocate(this->Names);
  this->Names = new (C) IdentifierInfo*[NumExprs];
  std::copy(Names, Names + NumExprs, this->Names);

  C.Deallocate(this->Exprs);
  this->Exprs = new (C) Stmt*[NumExprs];
  std::copy(Exprs, Exprs + NumExprs, this->Exprs);

  C.Deallocate(this->Constraints);
  this->Constraints = new (C) StringLiteral*[NumExprs];
  std::copy(Constraints, Constraints + NumExprs, this->Constraints);

  C.Deallocate(this->Clobbers);
  this->Clobbers = new (C) StringLiteral*[NumClobbers];
  std::copy(Clobbers, Clobbers + NumClobbers, this->Clobbers);
}

Example #2

File: ExprCXX.cpp Project: blickly/llvm-clang-PRETC

void CXXConstructExpr::Destroy(ASTContext &C) {
  DestroyChildren(C);
  if (Args)
    C.Deallocate(Args);
  this->~CXXConstructExpr();
  C.Deallocate(this);
}

Example #3

File: DeclCXX.cpp Project: Gcrosby5269/clamav-bytecode-compiler

void CXXRecordDecl::Destroy(ASTContext &C) {
  if (data().Definition == this) {
    C.Deallocate(data().Bases);
    C.Deallocate(data().VBases);
    C.Deallocate(&data());
  }
  this->RecordDecl::Destroy(C);
}

Example #4

File: DeclTemplate.cpp Project: silviubaranga/SHP

void ClassTemplateDecl::Destroy(ASTContext& C) {
    if (!PreviousDeclaration) {
        CommonPtr->~Common();
        C.Deallocate((void*)CommonPtr);
    }
    CommonPtr = 0;

    this->~ClassTemplateDecl();
    C.Deallocate((void*)this);
}

Example #5

File: RecordLayout.cpp Project: ujhpc/clang

void ASTRecordLayout::Destroy(ASTContext &Ctx) {
  if (FieldOffsets)
    Ctx.Deallocate(FieldOffsets);
  if (CXXInfo) {
    Ctx.Deallocate(CXXInfo);
    CXXInfo->~CXXRecordLayoutInfo();
  }
  this->~ASTRecordLayout();
  Ctx.Deallocate(this);
}

Example #6

void VarDecl::Destroy(ASTContext& C) {
  Expr *Init = getInit();
  if (Init) {
    Init->Destroy(C);
    if (EvaluatedStmt *Eval = this->Init.dyn_cast<EvaluatedStmt *>()) {
      Eval->~EvaluatedStmt();
      C.Deallocate(Eval);
    }
  }
  this->~VarDecl();
  C.Deallocate((void *)this);
}

Example #7

File: ExprCXX.cpp Project: blickly/llvm-clang-PRETC

void CXXConditionDeclExpr::Destroy(ASTContext& C) {
  // FIXME: Cannot destroy the decl here, because it is linked into the
  // DeclContext's chain.
  //getVarDecl()->Destroy(C);
  this->~CXXConditionDeclExpr();
  C.Deallocate(this);
}

Example #8

File: DeclTemplate.cpp Project: silviubaranga/SHP

void ClassTemplateSpecializationDecl::Destroy(ASTContext &C) {
    if (SpecializedPartialSpecialization *PartialSpec
            = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
        C.Deallocate(PartialSpec);

    CXXRecordDecl::Destroy(C);
}

Example #9

File: Stmt.cpp Project: blickly/llvm-clang-PRETC

void Stmt::Destroy(ASTContext &C) {
  DestroyChildren(C);
  // FIXME: Eventually all Stmts should be allocated with the allocator
  //  in ASTContext, just like with Decls.
  this->~Stmt();
  C.Deallocate((void *)this);
}

Example #10

void NamespaceDecl::Destroy(ASTContext& C) {
  // NamespaceDecl uses "NextDeclarator" to chain namespace declarations
  // together. They are all top-level Decls.

  this->~NamespaceDecl();
  C.Deallocate((void *)this);
}

Example #11

void Decl::Destroy(ASTContext &C) {
  // Free attributes for this decl.
  if (HasAttrs) {
    C.getDeclAttrs(this)->Destroy(C);
    invalidateAttrs();
    HasAttrs = false;
  }

#if 0
  // FIXME: Once ownership is fully understood, we can enable this code
  if (DeclContext *DC = dyn_cast<DeclContext>(this))
    DC->decls_begin()->Destroy(C);

  // Observe the unrolled recursion.  By setting N->NextDeclInContext = 0x0
  // within the loop, only the Destroy method for the first Decl
  // will deallocate all of the Decls in a chain.

  Decl* N = getNextDeclInContext();

  while (N) {
    Decl* Tmp = N->getNextDeclInContext();
    N->NextDeclInContext = 0;
    N->Destroy(C);
    N = Tmp;
  }

  this->~Decl();
  C.Deallocate((void *)this);
#endif
}

Example #12

File: Stmt.cpp Project: AaronBallman/tra-working

void CompoundStmt::setStmts(ASTContext &C, Stmt **Stmts, unsigned NumStmts) {
  if (this->Body)
    C.Deallocate(Body);
  this->CompoundStmtBits.NumStmts = NumStmts;

  Body = new (C) Stmt*[NumStmts];
  memcpy(Body, Stmts, sizeof(Stmt *) * NumStmts);
}

Example #13

void VarDecl::setInit(ASTContext &C, Expr *I) {
  if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) {
    Eval->~EvaluatedStmt();
    C.Deallocate(Eval);
  }

  Init = I;
}

Example #14

void Attr::Destroy(ASTContext &C) {
  if (Next) {
    Next->Destroy(C);
    Next = 0;
  }
  this->~Attr();
  C.Deallocate((void*)this);
}

Example #15

void BlockDecl::Destroy(ASTContext& C) {
  if (Body)
    Body->Destroy(C);

  for (param_iterator I=param_begin(), E=param_end(); I!=E; ++I)
    (*I)->Destroy(C);

  C.Deallocate(ParamInfo);
  Decl::Destroy(C);
}

Example #16

File: Stmt.cpp Project: elfprince13/clang

void CompoundStmt::setStmts(const ASTContext &C, ArrayRef<Stmt *> Stmts) {
  if (Body)
    C.Deallocate(Body);
  CompoundStmtBits.NumStmts = Stmts.size();
  assert(CompoundStmtBits.NumStmts == Stmts.size() &&
         "NumStmts doesn't fit in bits of CompoundStmtBits.NumStmts!");

  Body = new (C) Stmt*[Stmts.size()];
  std::copy(Stmts.begin(), Stmts.end(), Body);
}

Example #17

File: DeclTemplate.cpp Project: silviubaranga/SHP

void FunctionTemplateDecl::Destroy(ASTContext &C) {
    if (Common *CommonPtr = CommonOrPrev.dyn_cast<Common*>()) {
        for (llvm::FoldingSet<FunctionTemplateSpecializationInfo>::iterator
                Spec = CommonPtr->Specializations.begin(),
                SpecEnd = CommonPtr->Specializations.end();
                Spec != SpecEnd; ++Spec)
            C.Deallocate(&*Spec);
    }

    Decl::Destroy(C);
}

Example #18

File: Decl.cpp Project: Killfrra/llvm-kernel

void FunctionDecl::Destroy(ASTContext& C) {
  if (Body && Body.isOffset())
    Body.get(C.getExternalSource())->Destroy(C);

  for (param_iterator I=param_begin(), E=param_end(); I!=E; ++I)
    (*I)->Destroy(C);

  C.Deallocate(ParamInfo);

  Decl::Destroy(C);
}

Example #19

void FunctionDecl::Destroy(ASTContext& C) {
  if (Body && Body.isOffset())
    Body.get(C.getExternalSource())->Destroy(C);

  for (param_iterator I=param_begin(), E=param_end(); I!=E; ++I)
    (*I)->Destroy(C);

  FunctionTemplateSpecializationInfo *FTSInfo
    = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>();
  if (FTSInfo)
    C.Deallocate(FTSInfo);
  
  MemberSpecializationInfo *MSInfo
    = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>();
  if (MSInfo)
    C.Deallocate(MSInfo);
  
  C.Deallocate(ParamInfo);

  Decl::Destroy(C);
}

Example #20

File: FullExpr.cpp Project: Gcrosby5269/clamav-bytecode-compiler

void FullExpr::Destroy(ASTContext &Context) {
  if (Expr *E = SubExpr.dyn_cast<Expr *>()) {
    E->Destroy(Context);
    return;
  }
  
  ExprAndTemporaries *ET = SubExpr.get<ExprAndTemporaries *>();
  for (ExprAndTemporaries::temps_iterator i = ET->temps_begin(), 
       e = ET->temps_end(); i != e; ++i)
    (*i)->Destroy(Context);

  Context.Deallocate(ET);
}

Example #21

File: Expr.cpp Project: isanbard/flang

void APNumericStorage::setIntValue(ASTContext &C, const APInt &Val) {
  if (hasAllocation())
    C.Deallocate(pVal);

  BitWidth = Val.getBitWidth();
  unsigned NumWords = Val.getNumWords();
  const uint64_t* Words = Val.getRawData();
  if (NumWords > 1) {
    pVal = new (C) uint64_t[NumWords];
    std::copy(Words, Words + NumWords, pVal);
  } else if (NumWords == 1)
    VAL = Words[0];
  else
    VAL = 0;
}

Example #22

File: Expr.cpp Project: YabinHu/mlang

/// setNumArgs - This changes the number of arguments present in this call.
/// Any orphaned expressions are deleted by this, and any new operands are set
/// to null.
void
FunctionCall::setNumArgs(ASTContext& C, unsigned NumArgs) {
  // No change, just return.
  if (NumArgs == getNumArgs()) return;

  // If shrinking # arguments, just delete the extras and forgot them.
  if (NumArgs < getNumArgs()) {
    this->NumArgs = NumArgs;
    return;
  }

  // Otherwise, we are growing the # arguments.  New an bigger argument array.
  Stmt **NewSubExprs = new (C) Stmt*[NumArgs+1];
  // Copy over args.
  for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i)
    NewSubExprs[i] = SubExprs[i];
  // Null out new args.
  for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i)
    NewSubExprs[i] = 0;

  if (SubExprs) C.Deallocate(SubExprs);
  SubExprs = NewSubExprs;
  this->NumArgs = NumArgs;
}

Example #23

File: DeclCXX.cpp Project: Gcrosby5269/clamav-bytecode-compiler

void StaticAssertDecl::Destroy(ASTContext& C) {
  AssertExpr->Destroy(C);
  Message->Destroy(C);
  this->~StaticAssertDecl();
  C.Deallocate((void *)this);
}

Example #24

File: NestedNameSpecifier.cpp Project: blickly/llvm-clang-PRETC

void NestedNameSpecifier::Destroy(ASTContext &Context) {
  this->~NestedNameSpecifier();
  Context.Deallocate((void *)this);
}

Example #25

File: ExprCXX.cpp Project: blickly/llvm-clang-PRETC

void CXXExprWithTemporaries::Destroy(ASTContext &C) {
  DestroyChildren(C);
  this->~CXXExprWithTemporaries();
  C.Deallocate(this);
}

Example #26

File: Stmt.cpp Project: blickly/llvm-clang-PRETC

void DeclStmt::Destroy(ASTContext &C) {
  this->~DeclStmt();
  C.Deallocate((void *)this);
}

Example #27

File: ExprCXX.cpp Project: blickly/llvm-clang-PRETC

void CXXBindTemporaryExpr::Destroy(ASTContext &C) {
  Temp->Destroy(C);
  this->~CXXBindTemporaryExpr();
  C.Deallocate(this);
}

Example #28

File: DeclCXX.cpp Project: Gcrosby5269/clamav-bytecode-compiler

void
CXXConstructorDecl::Destroy(ASTContext& C) {
  C.Deallocate(BaseOrMemberInitializers);
  CXXMethodDecl::Destroy(C);
}

Example #29

File: ExprCXX.cpp Project: blickly/llvm-clang-PRETC

void CXXTemporary::Destroy(ASTContext &C) {
  this->~CXXTemporary();
  C.Deallocate(this);
}