Collaboration diagram for tm_ipa_cg_data:

Detailed Description

Interprocedual analysis for the creation of transactional clones.
  The aim of this pass is to find which functions are referenced in
  a non-irrevocable transaction context, and for those over which
  we have control (or user directive), create a version of the
  function which uses only the transactional interface to reference
  protected memories.  This analysis proceeds in several steps:

    (1) Collect the set of all possible transactional clones:

       (a) For all local public functions marked tm_callable, push
           it onto the tm_callee queue.

       (b) For all local functions, scan for calls in transaction blocks.
           Push the caller and callee onto the tm_caller and tm_callee
           queues.  Count the number of callers for each callee.

       (c) For each local function on the callee list, assume we will
           create a transactional clone.  Push *all* calls onto the
           callee queues; count the number of clone callers separately
           to the number of original callers.

    (2) Propagate irrevocable status up the dominator tree:

       (a) Any external function on the callee list that is not marked
           tm_callable is irrevocable.  Push all callers of such onto
           a worklist.

       (b) For each function on the worklist, mark each block that
           contains an irrevocable call.  Use the AND operator to
           propagate that mark up the dominator tree.

       (c) If we reach the entry block for a possible transactional
           clone, then the transactional clone is irrevocable, and
           we should not create the clone after all.  Push all
           callers onto the worklist.

       (d) Place tm_irrevocable calls at the beginning of the relevant
           blocks.  Special case here is the entry block for the entire
           transaction region; there we mark it GTMA_DOES_GO_IRREVOCABLE for
           the library to begin the region in serial mode.  Decrement
           the call count for all callees in the irrevocable region.

    (3) Create the transactional clones:

       Any tm_callee that still has a non-zero call count is cloned.

This structure is stored in the AUX field of each cgraph_node.

Field Documentation

◆ all_tm_regions

struct tm_region* tm_ipa_cg_data::all_tm_regions

Referenced by ipa_tm_execute(), ipa_tm_scan_calls_transaction(), ipa_tm_scan_irr_function(), and ipa_tm_transform_transaction().

◆ clone

struct cgraph_node* tm_ipa_cg_data::clone

Referenced by ipa_tm_create_version(), ipa_tm_create_version_alias(), ipa_tm_execute(), ipa_tm_transform_calls_redirect(), and ipa_tm_transform_clone().

◆ in_callee_queue

bool tm_ipa_cg_data::in_callee_queue

Referenced by ipa_tm_execute(), and ipa_tm_scan_calls_block().

◆ in_worklist

bool tm_ipa_cg_data::in_worklist

Referenced by ipa_tm_execute(), and ipa_tm_note_irrevocable().

◆ irrevocable_blocks_clone

bitmap tm_ipa_cg_data::irrevocable_blocks_clone

Referenced by ipa_tm_mayenterirr_function(), ipa_tm_scan_irr_function(), and ipa_tm_transform_clone().

◆ irrevocable_blocks_normal

bitmap tm_ipa_cg_data::irrevocable_blocks_normal

Referenced by ipa_tm_scan_irr_function(), and ipa_tm_transform_transaction().

◆ is_irrevocable

bool tm_ipa_cg_data::is_irrevocable

Referenced by ipa_tm_execute(), ipa_tm_mayenterirr_function(), ipa_tm_note_irrevocable(), and ipa_tm_scan_irr_block().

◆ tm_callers_clone

unsigned tm_ipa_cg_data::tm_callers_clone

Referenced by ipa_tm_decrement_clone_counts(), ipa_tm_execute(), and ipa_tm_scan_calls_block().

◆ tm_callers_normal

unsigned tm_ipa_cg_data::tm_callers_normal

Referenced by ipa_tm_decrement_clone_counts(), ipa_tm_execute(), and ipa_tm_scan_calls_block().

◆ transaction_blocks_normal

bitmap tm_ipa_cg_data::transaction_blocks_normal

Referenced by ipa_tm_note_irrevocable(), and ipa_tm_scan_calls_transaction().

◆ want_irr_scan_normal

bool tm_ipa_cg_data::want_irr_scan_normal