static int GetTypeOf(ea_t ea)
{
flags_t flags = getFlags(ea);
if (isTail(flags)) {
// check if it's a struct ptr
ea_t head = get_item_head(ea);
if (head == ea) return T_UNK;
flags = getFlags(head);
if (!isData(flags) || !isStruct(flags)) return T_UNK;
return GetTypeOfStructInstance(ea, head, flags);
}
if (!isData(flags)) return T_UNK;
if (isStruct(flags)) return GetTypeOfStructInstance(ea, ea, flags);
if (isByte(flags)) {
char s;
if (has_cmt(flags) && (get_cmt(ea, false, &s, 1) != -1) && s == 'S') return T_I8;
return T_U8;
}
if (isWord(flags)) {
char s;
if (has_cmt(flags) && (get_cmt(ea, false, &s, 1) != -1) && s == 'S') return T_I16;
return T_U16;
}
if (isDwrd(flags)) return T_I32;
return T_UNK;
}
void NonPrivateMemberVariablesInClassesCheck::registerMatchers(
MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
// We can ignore structs/classes with all member variables being public.
auto ShouldIgnoreRecord =
allOf(boolean(IgnoreClassesWithAllMemberVariablesBeingPublic),
unless(hasNonPublicMemberVariable()));
// There are three visibility types: public, protected, private.
// If we are ok with public fields, then we only want to complain about
// protected fields, else we want to complain about all non-private fields.
// We can ignore public member variables in structs/classes, in unions.
auto InterestingField = fieldDecl(
IgnorePublicMemberVariables ? isProtected() : unless(isPrivate()));
// We only want the records that not only contain the mutable data (non-static
// member variables), but also have some logic (non-static member functions).
// We may optionally ignore records where all the member variables are public.
Finder->addMatcher(cxxRecordDecl(anyOf(isStruct(), isClass()), hasMethods(),
hasNonStaticMethod(),
unless(ShouldIgnoreRecord),
forEach(InterestingField.bind("field")))
.bind("record"),
this);
}
std::string MxArray::fieldname(int fieldnumber) const
{
if (!isStruct())
mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not struct");
const char *fname = mxGetFieldNameByNumber(p_, fieldnumber);
if (!fname)
mexErrMsgIdAndTxt("mexopencv:error",
"Failed to get field name at %d\n", fieldnumber);
return std::string(fname);
}
std::vector<std::string> MxArray::fieldnames() const
{
if (!isStruct())
mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not a struct array");
int n = nfields();
std::vector<std::string> v;
v.reserve(n);
for (int i = 0; i < n; ++i)
v.push_back(fieldname(i));
return v;
}
void CloexecAcceptCheck::registerMatchers(MatchFinder *Finder) {
auto SockAddrPointerType =
hasType(pointsTo(recordDecl(isStruct(), hasName("sockaddr"))));
auto SockLenPointerType = hasType(pointsTo(namedDecl(hasName("socklen_t"))));
registerMatchersImpl(Finder,
functionDecl(returns(isInteger()), hasName("accept"),
hasParameter(0, hasType(isInteger())),
hasParameter(1, SockAddrPointerType),
hasParameter(2, SockLenPointerType)));
}
MxArray MxArray::at(const std::string& fieldName, mwIndex index) const
{
if (!isStruct())
mexErrMsgIdAndTxt("mexopencv:error", "MxArray is not struct");
if (numel() <= index)
mexErrMsgIdAndTxt("mexopencv:error", "Index out of range");
const mxArray* pm = mxGetField(p_, index, fieldName.c_str());
if (!pm)
mexErrMsgIdAndTxt("mexopencv:error",
"Field '%s' doesn't exist", fieldName.c_str());
return MxArray(pm);
}
void MatlabObject::checkScalar () const {
ASSERT (!isStruct ());
ASSERT (!isEmpty ());
size_t ndims = size ().size ();
if (ndims == 0) {
return;
} else if (ndims == 1) {
ASSERT (size ()[0] == 1);
} else if (ndims == 2) {
ASSERT (size ()[0] == 1 && size ()[1] == 1);
} else {
ABORT_MSG ("ndims is larger than 2");
}
}
unsigned int ShaderVariable::getBasicTypeElementCount() const
{
// GLES 3.1 Nov 2016 section 7.3.1.1 page 77 specifies that a separate entry should be generated
// for each array element when dealing with an array of arrays or an array of structs.
ASSERT(!isArrayOfArrays());
ASSERT(!isStruct() || !isArray());
// GLES 3.1 Nov 2016 page 82.
if (isArray())
{
return getOutermostArraySize();
}
return 1u;
}
std::vector<cv::DMatch> MxArray::toVector() const
{
int n = numel();
std::vector<cv::DMatch> v;
v.reserve(n);
if (isCell())
for (int i = 0; i < n; ++i)
v.push_back(at<MxArray>(i).toDMatch());
else if (isStruct())
for (int i = 0; i < n; ++i)
v.push_back(toDMatch(i));
else
mexErrMsgIdAndTxt("mexopencv:error",
"MxArray unable to convert to std::vector");
return v;
}
std::vector<cv::KeyPoint> MxArray::toVector() const
{
const mwSize n = numel();
std::vector<cv::KeyPoint> v;
v.reserve(n);
if (isCell())
for (mwIndex i = 0; i < n; ++i)
v.push_back(at<MxArray>(i).toKeyPoint());
else if (isStruct())
for (mwIndex i = 0; i < n; ++i)
v.push_back(toKeyPoint(i));
else
mexErrMsgIdAndTxt("mexopencv:error",
"MxArray unable to convert to std::vector<cv::KeyPoint>");
return v;
}
void DataMemberChecker::checkASTDecl(const clang::FieldDecl* D,
clang::ento::AnalysisManager& Mgr,
clang::ento::BugReporter& BR) const {
const char *reportDescription = "[sas.CodingConventions.FCCSW.DataMember] Data member variable names must begin with 'm_' followed by a lowerCamelCase name.";
std::regex correctRegex("^m_[a-z][a-zA-Z0-9]+");
auto nameString = D->getNameAsString();
auto parent = D->getParent();
if (parent->isStruct()) {
return;
// Does not apply to public members of structs
}
if (!std::regex_match(nameString, correctRegex)) {
Report(D, reportDescription, BR);
}
}
Var& Var::getAt(std::size_t n)
{
if (isVector())
return holderImpl<std::vector<Var>,
InvalidAccessException>("Not a vector.")->operator[](n);
else if (isList())
return holderImpl<std::list<Var>,
InvalidAccessException>("Not a list.")->operator[](n);
else if (isDeque())
return holderImpl<std::deque<Var>,
InvalidAccessException>("Not a deque.")->operator[](n);
else if (isStruct())
return structIndexOperator(holderImpl<Struct<int>,
InvalidAccessException>("Not a struct."), static_cast<int>(n));
else if (!isString() && !isEmpty() && (n == 0))
return *this;
throw RangeException("Index out of bounds.");
}
void Uniform::loadLocation(){
if (glIsProgram(shader) == GL_FALSE){
DebugUtility::log_err("ERROR: Called loadLocation of uniform %s before its shader was successfully linked\n", name.c_str());
return;
}
if (!isStruct()){
std::string realName = getRealName();
location = glGetUniformLocation(shader, realName.c_str());
if (location == -1u) {
DebugUtility::log_err("ERROR: Failed to load location of uniform %s\n", realName.c_str());
}
else{
}
}
else {
for (auto c : children){
c->loadLocation();
}
}
}
void enum_members2(struc_t *st)
{
char buf[MAXSTR];
type_t type[MAXSTR] = {0};
int gap_cnt = 1;
asize_t ofs = 0, gapend = BADADDR, gapstart = BADADDR;
for (size_t i=0;i<st->memqty;i++)
{
member_t &mem = st->members[i];
// unexpected beginning of member?
if (mem.soff != ofs)
{
// msg("gap detected @ %a!\n", ofs);
gapstart = ofs;
}
if (gapstart != BADADDR)
{
gapend = mem.soff;
msg("char pad%d[%d]\n", gap_cnt, gapend - gapstart);
//msg("gap size=%a\n", gapend - gapstart);
gapend = gapstart = BADADDR;
gap_cnt++;
}
typeinfo_t mem_ti;
retrieve_member_info(&mem, &mem_ti);
// data type size of member
asize_t dt_mem_size = get_data_type_size(mem.flag, &mem_ti);
// member size
asize_t mem_size = get_member_size(&mem);
// get the member's name
get_member_name(mem.id, buf, sizeof(buf));
char dtype[MAXSTR];
char arraystr[MAXSTR];
char typemod[10];
arraystr[0] = 0;
typemod[0] = 0;
if (isWord(mem.flag))
strcpy(dtype, "unsigned short");
else if (isDwrd(mem.flag))
strcpy(dtype, "unsigned long");
else if (isByte(mem.flag))
strcpy(dtype, "char");
else if (isStruct(mem.flag))
{
struc_t *nested_st = get_sptr(&mem);
get_struc_name(nested_st->id, dtype, MAXSTR);
}
else
strcpy(dtype, "user_type");
if (isOff0(mem.flag))
{
strcpy(typemod, "*");
}
if (isEnum0(mem.flag))
{
get_enum_name(mem_ti.ec.tid, dtype, sizeof(dtype));
}
asize_t ar_size = mem_size / dt_mem_size;
// an array?
if (ar_size > 1)
{
sprintf(arraystr, "[%d]", ar_size);
}
char out[100];
sprintf(out, "%s " /* type */
"%s" /* typemodif */ "%s" /* varname */ "%s" /*array*/ ";", dtype, typemod, buf, arraystr);
msg("%s\n", out);
/*
inline bool idaapi isByte (flags_t F) { return isData(F) && (F & DT_TYPE) == FF_BYTE; }
inline bool idaapi isWord (flags_t F) { return isData(F) && (F & DT_TYPE) == FF_WORD; }
inline bool idaapi isDwrd (flags_t F) { return isData(F) && (F & DT_TYPE) == FF_DWRD; }
inline bool idaapi isQwrd (flags_t F) { return isData(F) && (F & DT_TYPE) == FF_QWRD; }
inline bool idaapi isOwrd (flags_t F) { return isData(F) && (F & DT_TYPE) == FF_OWRD; }
inline bool idaapi isTbyt (flags_t F) { return isData(F) && (F & DT_TYPE) == FF_TBYT; }
inline bool idaapi isFloat (flags_t F) { return isData(F) && (F & DT_TYPE) == FF_FLOAT; }
inline bool idaapi isDouble(flags_t F) { return isData(F) && (F & DT_TYPE) == FF_DOUBLE; }
inline bool idaapi isPackReal(flags_t F) { return isData(F) && (F & DT_TYPE) == FF_PACKREAL; }
inline bool idaapi isASCII (flags_t F) { return isData(F) && (F & DT_TYPE) == FF_ASCI; }
inline bool idaapi isStruct(flags_t F) { return isData(F) && (F & DT_TYPE) == FF_STRU; }
inline bool idaapi is3byte (flags_t F) { return isData(F) && (F & DT_TYPE) == FF_3BYTE; }
*/
/*
msg("member[%d], name=%s; %a-%a ; id=%d; flags=%x type=%s dt_mem_size=%a mem_size=%a\n",
i,
buf,
mem.soff,
mem.eoff,
mem.id,
mem.flag,
type,
dt_mem_size,
mem_size);
*/
// we expect next member to begin @ end of last member
ofs = mem.eoff;
}
}
bool isCompleteStruct(const codeview_type* type, const BYTE* name, bool cstr)
{
return isStruct(type)
&& !(getStructProperty(type) & kPropIncomplete)
&& cmpStructName(type, name, cstr);
}
matvar_t *GetMatlabVariable(void *pvApiCtx, int iVar, const char *name, int matfile_version, int * parent, int item_position)
{
int * var_addr = NULL;
int var_type;
SciErr sciErr;
matvar_t * tmp_res = NULL;
if (parent == NULL)
{
sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &var_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return NULL;
}
sciErr = getVarType(pvApiCtx, var_addr, &var_type);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return NULL;
}
}
else
{
sciErr = getListItemAddress(pvApiCtx, parent, item_position, &var_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return NULL;
}
sciErr = getVarType(pvApiCtx, var_addr, &var_type);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return NULL;
}
}
switch (var_type)
{
case sci_matrix:
tmp_res = GetDoubleVariable(pvApiCtx, iVar, name, matfile_version, parent, item_position);
break;
case sci_strings:
tmp_res = GetCharVariable(pvApiCtx, iVar, name, parent, item_position);
break;
case sci_ints:
tmp_res = GetIntegerVariable(pvApiCtx, iVar, name, parent, item_position);
break;
case sci_mlist:
/* Only cells structs and hypermatrices are managed */
if (isCell(pvApiCtx, var_addr))
{
tmp_res = GetCellVariable(pvApiCtx, iVar, name, matfile_version, parent, item_position);
}
else if (isStruct(pvApiCtx, var_addr))
{
tmp_res = GetStructVariable(pvApiCtx, iVar, name, matfile_version, parent, item_position);
}
else
{
if (item_position > 0)
{
tmp_res = GetMlistVariable(pvApiCtx, iVar, name, matfile_version, parent, item_position);
}
else
{
tmp_res = GetMlistVariable(pvApiCtx, iVar, name, matfile_version, parent, -1);
}
}
break;
case sci_sparse:
if (item_position > 0)
{
tmp_res = GetSparseVariable(pvApiCtx, iVar, name, parent, item_position);
}
else
{
tmp_res = GetSparseVariable(pvApiCtx, iVar, name, parent, -1);
}
break;
default:
sciprint("Do not known how to get variable of type %d\n", var_type);
tmp_res = NULL;
}
return tmp_res;
}
/// TODO: add trivial marker for tagtypes
bool isTrivial(const TypePtr& type) {
auto ttype = type.isa<TagTypePtr>();
if(!ttype) {
if (core::lang::isArray(type)) {
// in case of an array, check the enclosed type for triviality
return isTrivial(core::lang::ArrayType(type).getElementType());
}
// non-tag-type & non-array types are always trivial
return true;
}
auto record = ttype->getRecord();
IRBuilder builder(type->getNodeManager());
auto containsCtor = [&](const LambdaExprPtr& ctor)->bool {
return any(record->getConstructors(), [&](const ExpressionPtr& cur) {
return *builder.normalize(cur) == *builder.normalize(ctor);
});
};
auto containsMemberFunction = [&](const MemberFunctionPtr& member)->bool {
return any(record->getMemberFunctions(), [&](const MemberFunctionPtr& cur) {
return *builder.normalize(cur) == *builder.normalize(member);
});
};
auto thisType = builder.refType(builder.tagTypeReference(record->getName()));
ParentsPtr parents =
(record.isa<StructPtr>()) ?
record.as<StructPtr>()->getParents() :
builder.parents();
// check for trivial constructors
bool trivialDefaultConstructor = containsCtor(builder.getDefaultConstructor(thisType, parents, record->getFields()));
if (!trivialDefaultConstructor) return false;
bool trivialCopyConstructor = containsCtor(builder.getDefaultCopyConstructor(thisType, parents, record->getFields()));
if (!trivialCopyConstructor) return false;
bool trivialMoveConstructor = containsCtor(builder.getDefaultMoveConstructor(thisType, parents, record->getFields()));
if (!trivialMoveConstructor) return false;
// check for trivial copy and move assignments
bool trivialCopyAssignment = containsMemberFunction(builder.getDefaultCopyAssignOperator(thisType, parents, record->getFields()));
if (!trivialCopyAssignment) return false;
bool trivialMoveAssignment = containsMemberFunction(builder.getDefaultMoveAssignOperator(thisType, parents, record->getFields()));
if (!trivialMoveAssignment) return false;
// check for trivial, non-virtual destructor
if(record->getDestructor().as<LambdaExprPtr>()->getBody().size() != 0 || record->getDestructorVirtual().getValue()) return false;
// check for virtual member functions
for(auto memFun : record->getMemberFunctions()) {
if(memFun->getVirtualFlag().getValue()) return false;
}
if(!record->getPureVirtualMemberFunctions().empty()) return false;
// check for virtual & non-trivial base classes
if(ttype->isStruct()) {
auto stype = ttype->getStruct();
for(auto par : stype->getParents()) {
if(par->getVirtual().getValue()) return false;
// if our direct base class is non-trivial, we cannot be trivial per-se
if(!isTrivial(par->getType())) return false;
}
}
// check that all non-static members are trivial
for(auto field : record->getFields()) {
auto fieldType = field->getType();
if(!isTrivial(fieldType)) return false;
//check cpp_ref field types
if(analysis::isRefType(fieldType) && lang::isCppReference(fieldType)) {
//TODO this is an over approximation which has to be refined
return false;
}
}
return true;
}
