1. A parallelizing compile method comprising: dividing a sequential program that controls an embedded system into a plurality of macro tasks according to a predetermined method, the sequential program being executed by a single processor system; generating a macro flow graph based on analysis of a control flow and a data dependency among the macro tasks; specifying, based on the control flow indicated in the macro flow graph, at least one pair of a starting end task and a termination end task, wherein the starting end task is a macro task that has a conditional branch, and the termination end task is one of macro tasks which are commonly executed among a plurality of a series of processings of the macro tasks to be sequentially executed from the starting end task as a start point; fusing (i) the starting end task specified by the specifying, (ii) the termination end task specified by the specifying, and (iii) a group of the macro tasks executed after execution of the starting end task and before execution of the termination end task into a block task so as to hide the conditional branch of the starting end task into the block task, wherein a plurality of block tasks are provided; extracting, based on the data dependency among the macro tasks including the block tasks after the fusing, parallelly-executable macro tasks that are parallelly-executable by a plurality of processor units included in a multiprocessor system; performing a static scheduling assigning the parallelly-executable macro tasks to the processor units, causing the parallelly-executable macro tasks to be parallelly executed by the plurality of processor units; and generating parallelized program to be executed by the multiprocessor system, based on a result of the static scheduling.