src/compiler/nir/nir_loop_analyze.h

   1 /*
   2  * Copyright © 2016 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #ifndef NIR_LOOP_ANALYZE_H
  25 #define NIR_LOOP_ANALYZE_H
  26
  27 #include "nir.h"
  28
  29 /* Returns true if nir_cf_node contains a jump other than the expected_jump
  30  * parameter.
  31  */
  32 static inline bool
  33 contains_other_jump(nir_cf_node *node, nir_instr *expected_jump)
  34 {
  35    switch (node->type) {
  36    case nir_cf_node_block: {
  37       nir_instr *lst_instr = nir_block_last_instr(nir_cf_node_as_block(node));
  38
  39       /* dead_cf should have eliminated any instruction after the first break
  40        */
  41       nir_foreach_instr(instr, nir_cf_node_as_block(node))
  42          assert(instr->type != nir_instr_type_jump || instr == lst_instr);
  43
  44       if (lst_instr && lst_instr->type == nir_instr_type_jump &&
  45           lst_instr != expected_jump)
  46          return true;
  47       else
  48          return false;
  49    }
  50    case nir_cf_node_if: {
  51       nir_if *if_stmt = nir_cf_node_as_if(node);
  52
  53       foreach_list_typed_safe(nir_cf_node, node, node, &if_stmt->then_list) {
  54          if (contains_other_jump(node, expected_jump))
  55             return true;
  56       }
  57
  58       foreach_list_typed_safe(nir_cf_node, node, node, &if_stmt->else_list) {
  59          if (contains_other_jump(node, expected_jump))
  60             return true;
  61       }
  62
  63       return false;
  64    }
  65    case nir_cf_node_loop:
  66       return true;
  67
  68    default:
  69       unreachable("Unhandled cf node type");
  70    }
  71 }
  72
  73 /* Here we define a trivial if as containing only a single break that must be
  74  * located at the end of either the then or else branch of the top level if,
  75  * there must be no other breaks or any other type of jump.  Or we pass NULL
  76  * to break_block the if must contains no jumps at all.
  77  */
  78 static inline bool
  79 nir_is_trivial_loop_if(nir_if *nif, nir_block *break_block)
  80 {
  81    nir_instr *last_instr = NULL;
  82
  83    if (break_block) {
  84       last_instr = nir_block_last_instr(break_block);
  85       assert(last_instr && last_instr->type == nir_instr_type_jump &&
  86              nir_instr_as_jump(last_instr)->type == nir_jump_break);
  87    }
  88
  89    if (contains_other_jump(&nif->cf_node, last_instr))
  90       return false;
  91
  92    return true;
  93 }
  94
  95 static inline bool
  96 nir_block_ends_in_break(nir_block *block)
  97 {
  98    if (exec_list_is_empty(&block->instr_list))
  99       return false;
 100
 101    nir_instr *instr = nir_block_last_instr(block);
 102    return instr->type == nir_instr_type_jump &&
 103       nir_instr_as_jump(instr)->type == nir_jump_break;
 104 }
 105
 106 #endif /* NIR_LOOP_ANALYZE_H */