File list_functions_with_unnecessary_checks_template... of Package Deletion_of_checks_before_specific_function_cal...

Overview Repositories Revisions Requests Users Attributes Meta

File list_functions_with_unnecessary_checks_template-with_static1.cocci of Package Deletion_of_checks_before_specific_function_calls_in_Linux_source_files (Revision aabfc3f59a9a7cfa2a0952d48165a55b)

Currently displaying revision aabfc3f59a9a7cfa2a0952d48165a55b , Show latest

// Copyright (c) 2015 Markus Elfring
//
// This file is part of a script collection for static source code analysis.
//
// The collection is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License (version 2)
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

@initialize:python@
@@
import sqlalchemy, sys
sys.stderr.write("\n".join(["Using SQLAlchemy version:",
                            sqlalchemy.__version__]))
sys.stderr.write("\n")
from sqlalchemy.exc import IntegrityError
from sqlalchemy import create_engine, Column, Integer, String
engine = create_engine("sqlite:///:memory:", echo = False)

from sqlalchemy.ext.declarative import declarative_base
base = declarative_base()

class position(base):
   __tablename__ = "positions"
   function = Column(String, primary_key = True)
   source_file = Column(String, primary_key = True)
   line = Column(Integer, primary_key = True)
   column = Column(Integer, primary_key = True)
   pattern = Column(Integer, primary_key = True)
   static = Column(Integer, default = 0)

from sqlalchemy.orm import sessionmaker
configured_session = sessionmaker(bind = engine)
session = configured_session()
base.metadata.create_all(engine)

def store_positions(fun, places):
    """Add source code positions to an internal table."""
    for place in places:
       entry = position(function = fun,
                        source_file = place.file,
                        line = place.line,
                        column = int(place.column) + 1,
                        pattern = 1
                       )
       session.add(entry)

def store_static(fun, places):
    """Record that a function is static."""
    for place in places:
        session.query(position) \
               .filter_by(function = fun,
                          source_file = place.file,
                          line = place.line,
                          column = int(place.column) + 1
                         ) \
               .update({"static": 1})

def store_static2(fun, places, area):
    """Add source code positions to an internal table."""
    for place in places:
       entry = position(function = fun,
                        source_file = place.file,
                        line = place.line,
                        column = int(place.column) + 1,
                        pattern = area,
                        static = 1
                       )
       session.add(entry)

@is_unnecessary_check@
expression data;
identifier work,
           release =~ "^(?x)
(?:
   (?:kz?|slob_)free
|
   (?:
# Alternation placeholder
   )
)$";
position pos;
type return_type;
@@
 return_type work@pos(...)
 {
  ... when any
  if (
(
      data
|
      likely(data)
)
     )
     release(data);
  ... when any
 }

@script:python collection depends on is_unnecessary_check@
fun << is_unnecessary_check.work;
places << is_unnecessary_check.pos;
@@
store_positions(fun, places)

@find_static depends on is_unnecessary_check@
identifier is_unnecessary_check.work;
position is_unnecessary_check.pos;
type is_unnecessary_check.return_type;
@@
 static return_type work@pos(...)
 {
  ...
 }

@script:python addition depends on find_static@
fun << is_unnecessary_check.work;
places << is_unnecessary_check.pos;
@@
store_static(fun, places)

@safety_check@
expression express;
identifier input, work;
type input_type, return_type;
position pos;
statement is, es;
@@
 static return_type work@pos(input_type input)
 {
  ... when any
(
  if (
(
      input
|
      likely(input)
|
      input > express
|
      input >= express
|
      input < express
|
      input <= express
)
     )
     is
  else
     es
|
  switch (input) { case 0: return ... ; ... }
)
  ... when any
 }

@script:python safety_check_collection depends on safety_check@
fun << safety_check.work;
places << safety_check.pos;
@@
store_static2(fun, places, 2)

@safety_check_with_pointer@
identifier input, local, member, process, work;
position pos;
statement is, es;
type cast_type, data_type, input_type, return_type;
@@
 static return_type work@pos(input_type * input)
 {
  ... when any
(
  if (
(
      !input
|
      unlikely(ZERO_OR_NULL_PTR(input))
|
      !input
      || !process(
(
                  input
|
                  input->member
|
                  & input->member
)
                 )
|
      input
      && process(
(
                 input
|
                 input->member
|
                 & input->member
)
                )
)
     )
     is
  else
     es
|
  data_type local = (cast_type) input;

if (unlikely(ZERO_OR_NULL_PTR(local)))
     is
  else
     es
)
  ... when any
 }

@script:python safety_check_collection_with_pointer
 depends on safety_check_with_pointer@
fun << safety_check_with_pointer.work;
places << safety_check_with_pointer.pos;
@@
store_static2(fun, places, 3)

@void_single_function_call depends on safety_check@
identifier caller, input, member, safety_check.work;
type input_type;
position pos;
@@
 static void caller@pos(..., input_type input, ...)
 {
(
  work(
(
       input
|
       input.member
)
      );
|
  work(
(
       input
|
       input.member
)
      );
  return;
)
 }

@script:python single_call_collection depends on void_single_function_call@
fun << void_single_function_call.caller;
places << void_single_function_call.pos;
@@
store_static2(fun, places, 4)

@non_void_single_function_call depends on safety_check@
expression return_value;
identifier caller, input, member, safety_check.work;
type input_type, return_type;
position pos;
@@
 static return_type caller@pos(..., input_type input, ...)
 {
  work(
(
       input
|
       input.member
)
      );
  return return_value;
 }

@script:python non_void_single_call_collection
 depends on non_void_single_function_call@
fun << non_void_single_function_call.caller;
places << non_void_single_function_call.pos;
@@
store_static2(fun, places, 5)

@void_single_function_call_with_pointer depends on safety_check_with_pointer@
identifier caller, input, safety_check_with_pointer.work;
type input_type;
position pos;
@@
 static void caller@pos(..., input_type * input, ...)
 {
(
  work(input);
|
  work(input);
  return;
)
 }

@script:python single_call_collection_with_pointer
 depends on void_single_function_call_with_pointer@
fun << void_single_function_call_with_pointer.caller;
places << void_single_function_call_with_pointer.pos;
@@
store_static2(fun, places, 6)

@non_void_single_function_call_with_pointer depends on safety_check_with_pointer@
expression return_value;
identifier caller, input, safety_check_with_pointer.work;
type input_type, return_type;
position pos;
@@
 static return_type caller@pos(..., input_type * input, ...)
 {
  work(input);
  return return_value;
 }

@script:python non_void_single_call_collection_with_pointer
 depends on non_void_single_function_call_with_pointer@
fun << non_void_single_function_call_with_pointer.caller;
places << non_void_single_function_call_with_pointer.pos;
@@
store_static2(fun, places, 7)

@finalize:python@
@@
try:
   session.commit()

except IntegrityError:
   # Data might be recorded already.
   sys.stderr.write("IntegrityError detected!\n")
   session.rollback()

except:
   raise
          
from sqlalchemy import func
entries = session.query(func.count("*")).select_from(position).scalar()

if entries > 0:
   delimiter = "|"
   sys.stdout.write(delimiter.join(["static",
                                    "function",
                                    '"source file"',
                                    "line",
                                    "column"
                                   ]))
   sys.stdout.write("\r\n")
   mark = ['"', '', '"']

for function, \
       file, \
       line, \
       column, \
       static in session.query(position.function,
                               position.source_file,
                               position.line,
                               position.column,
                               position.static
                              ).distinct() \
                               .order_by(position.source_file,
                                         position.function,
                                         position.line,
                                         position.column
                                        ):
      mark[1] = file
      sys.stdout.write(delimiter.join([str(static),
                                       function,
                                       ''.join(mark),
                                       str(line),
                                       str(column)
                                      ]))
      sys.stdout.write("\r\n")
else:
   sys.stderr.write("No result for this analysis!\n")

Places

File list_functions_with_unnecessary_checks_template-with_static1.cocci of Package Deletion_of_checks_before_specific_function_calls_in_Linux_source_files (Revision aabfc3f59a9a7cfa2a0952d48165a55b)

Places