495 lines
14 KiB
C
495 lines
14 KiB
C
/* Implement timing-related actions for CHILL.
|
|
Copyright (C) 1992, 93, 1994, 1998 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU CC.
|
|
|
|
GNU CC is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU CC 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 GNU CC; see the file COPYING. If not, write to
|
|
the Free Software Foundation, 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "tree.h"
|
|
#include "rtl.h"
|
|
#include "ch-tree.h"
|
|
#include "flags.h"
|
|
#include "input.h"
|
|
#include "obstack.h"
|
|
#include "lex.h"
|
|
#include "toplev.h"
|
|
|
|
#ifndef LONG_TYPE_SIZE
|
|
#define LONG_TYPE_SIZE BITS_PER_WORD
|
|
#endif
|
|
|
|
/* set non-zero if input text is forced to lowercase */
|
|
extern int ignore_case;
|
|
|
|
/* set non-zero if special words are to be entered in uppercase */
|
|
extern int special_UC;
|
|
|
|
/* timing modes */
|
|
tree abs_timing_type_node;
|
|
tree duration_timing_type_node;
|
|
|
|
/* rts time type */
|
|
static tree rtstime_type_node = NULL_TREE;
|
|
|
|
/* the stack for AFTER primval [ DELAY ] IN
|
|
and has following layout
|
|
|
|
TREE_VALUE (TREE_VALUE (after_stack)) = current time or NULL_TREE (if DELAY specified)
|
|
TREE_PURPOSE (TREE_VALUE (after_stack)) = the duration location
|
|
TREE_VALUE (TREE_PURPOSE (after_stack)) = label at TIMEOUT
|
|
TREE_PURPOSE (TREE_PURPOSE (after_stack)) = label at the end of AFTER action
|
|
*/
|
|
tree after_stack = NULL_TREE;
|
|
|
|
/* in pass 1 we need a seperate list for the labels */
|
|
static tree after_stack_pass_1 = NULL_TREE;
|
|
static tree after_help;
|
|
|
|
void
|
|
timing_init ()
|
|
{
|
|
tree ptr_ftype_durt_ptr_int;
|
|
tree int_ftype_abst_ptr_int;
|
|
tree void_ftype_ptr;
|
|
tree long_ftype_int_int_int_int_int_int_int_ptr_int;
|
|
tree void_ftype_abstime_ptr;
|
|
tree int_ftype_ptr_durt_ptr;
|
|
tree void_ftype_durt_ptr;
|
|
tree void_ftype_ptr_durt_ptr_int;
|
|
tree temp;
|
|
tree endlink;
|
|
tree ulong_type;
|
|
|
|
ulong_type = TREE_TYPE (lookup_name (
|
|
get_identifier ((ignore_case || ! special_UC ) ?
|
|
"ulong" : "ULONG")));
|
|
|
|
/* build modes for TIME and DURATION */
|
|
duration_timing_type_node = make_unsigned_type (LONG_TYPE_SIZE);
|
|
temp = pushdecl (build_decl (TYPE_DECL, ridpointers[(int)RID_DURATION],
|
|
duration_timing_type_node));
|
|
SET_CH_NOVELTY_NONNIL (duration_timing_type_node, temp);
|
|
abs_timing_type_node = make_unsigned_type (LONG_TYPE_SIZE);
|
|
temp = pushdecl (build_decl (TYPE_DECL, ridpointers[(int)RID_TIME],
|
|
abs_timing_type_node));
|
|
SET_CH_NOVELTY_NONNIL (abs_timing_type_node, temp);
|
|
|
|
/* the mode of time the runtimesystem returns */
|
|
if (rtstime_type_node == NULL_TREE)
|
|
{
|
|
tree decl1, decl2, result;
|
|
|
|
decl1 = build_decl (FIELD_DECL,
|
|
get_identifier ("secs"),
|
|
ulong_type);
|
|
DECL_INITIAL (decl1) = NULL_TREE;
|
|
decl2 = build_decl (FIELD_DECL,
|
|
get_identifier ("nsecs"),
|
|
ulong_type);
|
|
DECL_INITIAL (decl2) = NULL_TREE;
|
|
TREE_CHAIN (decl2) = NULL_TREE;
|
|
TREE_CHAIN (decl1) = decl2;
|
|
|
|
result = build_chill_struct_type (decl1);
|
|
pushdecl (temp = build_decl (TYPE_DECL,
|
|
get_identifier ("__tmp_rtstime"), result));
|
|
DECL_SOURCE_LINE (temp) = 0;
|
|
satisfy_decl (temp, 0);
|
|
rtstime_type_node = TREE_TYPE (temp);
|
|
}
|
|
|
|
endlink = void_list_node;
|
|
|
|
ptr_ftype_durt_ptr_int
|
|
= build_function_type (ptr_type_node,
|
|
tree_cons (NULL_TREE, duration_timing_type_node,
|
|
tree_cons (NULL_TREE, ptr_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
endlink))));
|
|
|
|
int_ftype_abst_ptr_int
|
|
= build_function_type (integer_type_node,
|
|
tree_cons (NULL_TREE, abs_timing_type_node,
|
|
tree_cons (NULL_TREE, ptr_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
endlink))));
|
|
|
|
void_ftype_ptr
|
|
= build_function_type (void_type_node,
|
|
tree_cons (NULL_TREE, ptr_type_node,
|
|
endlink));
|
|
|
|
long_ftype_int_int_int_int_int_int_int_ptr_int
|
|
= build_function_type (abs_timing_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
tree_cons (NULL_TREE, ptr_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
endlink))))))))));
|
|
|
|
void_ftype_abstime_ptr
|
|
= build_function_type (void_type_node,
|
|
tree_cons (NULL_TREE, abs_timing_type_node,
|
|
tree_cons (NULL_TREE, ptr_type_node,
|
|
endlink)));
|
|
|
|
int_ftype_ptr_durt_ptr
|
|
= build_function_type (integer_type_node,
|
|
tree_cons (NULL_TREE, ptr_type_node,
|
|
tree_cons (NULL_TREE, duration_timing_type_node,
|
|
tree_cons (NULL_TREE, ptr_type_node,
|
|
endlink))));
|
|
|
|
void_ftype_durt_ptr
|
|
= build_function_type (void_type_node,
|
|
tree_cons (NULL_TREE, duration_timing_type_node,
|
|
tree_cons (NULL_TREE, ptr_type_node,
|
|
endlink)));
|
|
|
|
void_ftype_ptr_durt_ptr_int
|
|
= build_function_type (void_type_node,
|
|
tree_cons (NULL_TREE, ptr_type_node,
|
|
tree_cons (NULL_TREE, duration_timing_type_node,
|
|
tree_cons (NULL_TREE, ptr_type_node,
|
|
tree_cons (NULL_TREE, integer_type_node,
|
|
endlink)))));
|
|
|
|
builtin_function ("_abstime", long_ftype_int_int_int_int_int_int_int_ptr_int,
|
|
NOT_BUILT_IN, NULL_PTR);
|
|
builtin_function ("__check_cycle", void_ftype_ptr_durt_ptr_int,
|
|
NOT_BUILT_IN, NULL_PTR);
|
|
builtin_function ("__convert_duration_rtstime", void_ftype_durt_ptr,
|
|
NOT_BUILT_IN, NULL_PTR);
|
|
builtin_function ("__define_timeout", ptr_ftype_durt_ptr_int,
|
|
NOT_BUILT_IN, NULL_PTR);
|
|
builtin_function ("_inttime", void_ftype_abstime_ptr,
|
|
NOT_BUILT_IN, NULL_PTR);
|
|
builtin_function ("__remaintime", int_ftype_ptr_durt_ptr,
|
|
NOT_BUILT_IN, NULL_PTR);
|
|
builtin_function ("__rtstime", void_ftype_ptr,
|
|
NOT_BUILT_IN, NULL_PTR);
|
|
builtin_function ("__wait_until", int_ftype_abst_ptr_int,
|
|
NOT_BUILT_IN, NULL_PTR);
|
|
}
|
|
|
|
#if 0
|
|
*
|
|
* build AT action
|
|
*
|
|
* AT primval IN
|
|
* ok-actionlist
|
|
* TIMEOUT
|
|
* to-actionlist
|
|
* END;
|
|
*
|
|
* gets translated to
|
|
*
|
|
* if (__wait_until (primval) == 0)
|
|
* ok-actionlist
|
|
* else
|
|
* to-action-list
|
|
*
|
|
#endif
|
|
|
|
void
|
|
build_at_action (t)
|
|
tree t;
|
|
{
|
|
tree abstime, expr, filename, fcall;
|
|
|
|
if (t == NULL_TREE || TREE_CODE (t) == ERROR_MARK)
|
|
abstime = convert (abs_timing_type_node, build_int_2 (0, 0));
|
|
else
|
|
abstime = t;
|
|
|
|
if (TREE_TYPE (abstime) != abs_timing_type_node)
|
|
{
|
|
error ("absolute time value must be of mode TIME.");
|
|
abstime = convert (abs_timing_type_node, build_int_2 (0, 0));
|
|
}
|
|
filename = force_addr_of (get_chill_filename ());
|
|
fcall = build_chill_function_call (
|
|
lookup_name (get_identifier ("__wait_until")),
|
|
tree_cons (NULL_TREE, abstime,
|
|
tree_cons (NULL_TREE, filename,
|
|
tree_cons (NULL_TREE, get_chill_linenumber (), NULL_TREE))));
|
|
expr = build (EQ_EXPR, integer_type_node, fcall, integer_zero_node);
|
|
expand_start_cond (expr, 0);
|
|
emit_line_note (input_filename, lineno);
|
|
}
|
|
|
|
#if 0
|
|
*
|
|
* build CYCLE action
|
|
*
|
|
* CYCLE primval IN
|
|
* actionlist
|
|
* END;
|
|
*
|
|
* gets translated to
|
|
*
|
|
* {
|
|
* RtsTime now;
|
|
* label:
|
|
* __rtstime (&now);
|
|
* actionlist
|
|
* __check_cycle (&now, primval, filename, lineno);
|
|
* goto label;
|
|
* }
|
|
*
|
|
#endif
|
|
|
|
tree
|
|
build_cycle_start (t)
|
|
tree t;
|
|
{
|
|
tree purpose = build_tree_list (NULL_TREE, NULL_TREE);
|
|
tree toid = build_tree_list (purpose, NULL_TREE);
|
|
|
|
/* define the label. Note: define_label needs to be called in
|
|
pass 1 and pass 2. */
|
|
TREE_VALUE (toid) = define_label (input_filename, lineno,
|
|
get_unique_identifier ("CYCLE_label"));
|
|
if (! ignoring)
|
|
{
|
|
tree duration_value, now_location;
|
|
|
|
if (t == NULL_TREE || TREE_CODE (t) == ERROR_MARK)
|
|
duration_value = convert (duration_timing_type_node, build_int_2 (0,0));
|
|
else
|
|
duration_value = t;
|
|
|
|
if (TREE_TYPE (duration_value) != duration_timing_type_node)
|
|
{
|
|
error ("duration primitive value must be of mode DURATION.");
|
|
duration_value = convert (duration_timing_type_node, build_int_2 (0,0));
|
|
}
|
|
TREE_PURPOSE (TREE_PURPOSE (toid)) = duration_value;
|
|
/* define the variable */
|
|
now_location = decl_temp1 (get_unique_identifier ("CYCLE_var"),
|
|
rtstime_type_node, 0,
|
|
NULL_TREE, 0, 0);
|
|
TREE_VALUE (TREE_PURPOSE (toid)) = force_addr_of (now_location);
|
|
|
|
/* build the call to __rtstime */
|
|
expand_expr_stmt (
|
|
build_chill_function_call (lookup_name (get_identifier ("__rtstime")),
|
|
build_tree_list (NULL_TREE, TREE_VALUE (TREE_PURPOSE (toid)))));
|
|
}
|
|
|
|
return toid;
|
|
}
|
|
|
|
void
|
|
build_cycle_end (toid)
|
|
tree toid;
|
|
{
|
|
tree filename, linenumber;
|
|
|
|
/* here we call __check_cycle and then jump to beginning of this
|
|
action */
|
|
filename = force_addr_of (get_chill_filename ());
|
|
linenumber = get_chill_linenumber ();
|
|
expand_expr_stmt (
|
|
build_chill_function_call (
|
|
lookup_name (get_identifier ("__check_cycle")),
|
|
tree_cons (NULL_TREE, TREE_VALUE (TREE_PURPOSE (toid)),
|
|
tree_cons (NULL_TREE, TREE_PURPOSE (TREE_PURPOSE (toid)),
|
|
tree_cons (NULL_TREE, filename,
|
|
tree_cons (NULL_TREE, linenumber, NULL_TREE))))));
|
|
expand_goto (TREE_VALUE (toid));
|
|
}
|
|
|
|
#if 0
|
|
*
|
|
* build AFTER ACTION
|
|
*
|
|
* AFTER primval [ DELAY ] IN
|
|
* action-list
|
|
* TIMEOUT
|
|
* to-action-list
|
|
* END
|
|
*
|
|
* gets translated to
|
|
*
|
|
* {
|
|
* struct chill_time __now;
|
|
* duration dur = primval;
|
|
* if (! delay_spceified)
|
|
* __rts_time (&__now);
|
|
* .
|
|
* .
|
|
* goto end-label;
|
|
* to-label:
|
|
* .
|
|
* .
|
|
* end-label:
|
|
* }
|
|
*
|
|
#endif
|
|
|
|
void
|
|
build_after_start (duration, delay_flag)
|
|
tree duration;
|
|
int delay_flag;
|
|
{
|
|
tree value, purpose;
|
|
|
|
if (! ignoring)
|
|
{
|
|
value = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE);
|
|
purpose = after_stack_pass_1;
|
|
after_stack_pass_1 = TREE_CHAIN (after_stack_pass_1);
|
|
after_stack = tree_cons (purpose, value, after_stack);
|
|
|
|
if (TREE_TYPE (duration) != duration_timing_type_node)
|
|
{
|
|
error ("duration primitive value must be of mode DURATION.");
|
|
duration = convert (duration_timing_type_node, build_int_2 (0,0));
|
|
}
|
|
TREE_PURPOSE (value) = decl_temp1 (get_identifier ("AFTER_duration"),
|
|
duration_timing_type_node, 0,
|
|
duration, 0, 0);
|
|
|
|
if (! delay_flag)
|
|
{
|
|
/* in this case we have to get the current time */
|
|
TREE_VALUE (value) = decl_temp1 (get_unique_identifier ("AFTER_now"),
|
|
rtstime_type_node, 0,
|
|
NULL_TREE, 0, 0);
|
|
/* build the function call to initialize the variable */
|
|
expand_expr_stmt (
|
|
build_chill_function_call (lookup_name (get_identifier ("__rtstime")),
|
|
build_tree_list (NULL_TREE, force_addr_of (TREE_VALUE (value)))));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* in pass 1 we just save the labels */
|
|
after_help = tree_cons (NULL_TREE, NULL_TREE, after_help);
|
|
after_stack_pass_1 = chainon (after_stack_pass_1, after_help);
|
|
}
|
|
}
|
|
|
|
void
|
|
build_after_timeout_start ()
|
|
{
|
|
tree label_name;
|
|
|
|
if (! ignoring)
|
|
{
|
|
/* jump to the end of AFTER action */
|
|
lookup_and_expand_goto (TREE_PURPOSE (TREE_PURPOSE (after_stack)));
|
|
label_name = TREE_VALUE (TREE_PURPOSE (after_stack));
|
|
/* mark we are in TIMEOUT part of AFTER action */
|
|
TREE_VALUE (TREE_PURPOSE (after_stack)) = NULL_TREE;
|
|
}
|
|
else
|
|
{
|
|
label_name = get_unique_identifier ("AFTER_tolabel");
|
|
TREE_VALUE (after_help) = label_name;
|
|
}
|
|
define_label (input_filename, lineno, label_name);
|
|
}
|
|
|
|
void
|
|
build_after_end ()
|
|
{
|
|
tree label_name;
|
|
|
|
/* define the end label */
|
|
if (! ignoring)
|
|
{
|
|
label_name = TREE_PURPOSE (TREE_PURPOSE (after_stack));
|
|
after_stack = TREE_CHAIN (after_stack);
|
|
}
|
|
else
|
|
{
|
|
label_name = get_unique_identifier ("AFTER_endlabel");
|
|
TREE_PURPOSE (after_help) = label_name;
|
|
after_help = TREE_CHAIN (after_help);
|
|
}
|
|
define_label (input_filename, lineno, label_name);
|
|
}
|
|
|
|
tree
|
|
build_timeout_preface ()
|
|
{
|
|
tree timeout_value = null_pointer_node;
|
|
|
|
if (after_stack != NULL_TREE &&
|
|
TREE_VALUE (TREE_PURPOSE (after_stack)) != NULL_TREE)
|
|
{
|
|
tree to_loc;
|
|
|
|
to_loc = decl_temp1 (get_unique_identifier ("TOloc"),
|
|
rtstime_type_node, 0, NULL_TREE, 0, 0);
|
|
timeout_value = force_addr_of (to_loc);
|
|
|
|
if (TREE_VALUE (TREE_VALUE (after_stack)) == NULL_TREE)
|
|
{
|
|
/* DELAY specified -- just call __convert_duration_rtstime for
|
|
given duration value */
|
|
expand_expr_stmt (
|
|
build_chill_function_call (
|
|
lookup_name (get_identifier ("__convert_duration_rtstime")),
|
|
tree_cons (NULL_TREE, TREE_PURPOSE (TREE_VALUE (after_stack)),
|
|
tree_cons (NULL_TREE, timeout_value, NULL_TREE))));
|
|
}
|
|
else
|
|
{
|
|
/* delay not specified -- call __remaintime which returns the
|
|
remaining time of duration in rtstime format and check the
|
|
result */
|
|
tree fcall =
|
|
build_chill_function_call (
|
|
lookup_name (get_identifier ("__remaintime")),
|
|
tree_cons (NULL_TREE, force_addr_of (TREE_VALUE (TREE_VALUE (after_stack))),
|
|
tree_cons (NULL_TREE, TREE_PURPOSE (TREE_VALUE (after_stack)),
|
|
tree_cons (NULL_TREE, timeout_value, NULL_TREE))));
|
|
tree expr = build (NE_EXPR, integer_type_node,
|
|
fcall, integer_zero_node);
|
|
expand_start_cond (expr, 0);
|
|
lookup_and_expand_goto (TREE_VALUE (TREE_PURPOSE (after_stack)));
|
|
expand_end_cond ();
|
|
}
|
|
}
|
|
return timeout_value;
|
|
}
|
|
|
|
void
|
|
build_timesupervised_call (fcall, to_loc)
|
|
tree fcall;
|
|
tree to_loc;
|
|
{
|
|
if (to_loc == null_pointer_node)
|
|
expand_expr_stmt (fcall);
|
|
else
|
|
{
|
|
tree expr = build (NE_EXPR, integer_type_node, fcall, integer_zero_node);
|
|
expand_start_cond (expr, 0);
|
|
lookup_and_expand_goto (TREE_VALUE (TREE_PURPOSE (after_stack)));
|
|
expand_end_cond ();
|
|
}
|
|
}
|