#include "beemitter_binary.h"
#include "obst.h"
#include "pdeq.h"
+#include "error.h"
static code_fragment_t *first_fragment;
static code_fragment_t *last_fragment;
be_emit(8/16/32/entity) call!) */
code_fragment_t *be_get_current_fragment(void)
{
- assert(obstack_object_size(&code_fragment_obst) >= sizeof(code_fragment_t));
code_fragment_t *fragment = obstack_base(&code_fragment_obst);
+ assert(obstack_object_size(&code_fragment_obst) >= sizeof(code_fragment_t));
assert(fragment->magic == CODE_FRAGMENT_MAGIC);
return fragment;
return offset;
}
-static bool determine_jumpsize_pass(const binary_emiter_interface_t *interface)
+static bool determine_jumpsize_iteration(
+ const binary_emiter_interface_t *interface)
{
unsigned offset = 0;
unsigned max_offset = 0;
max_offset = align(max_offset, alignment);
if (offset != fragment->offset) {
- changed = true;
+ changed = true;
fragment->offset = offset;
}
fragment->max_offset = max_offset;
first_fragment->offset = 0;
first_fragment->max_offset = 0;
- /* pass1: encode minimum/maximum offsets into fragments */
+ /* The algorithm calculates a lower and upper bound for the offset of each
+ * fragment. With this information we can calculate a lower and upper bound
+ * for the size of each jump instruction.
+ * A single iteration updates the offset bounds for all fragments and jump
+ * sizes for each fragment. We iterate until we had an iteration where
+ * none of the minimum offsets changed. */
do {
- changed = determine_jumpsize_pass(interface);
+ changed = determine_jumpsize_iteration(interface);
/* TODO: we should have an abort mode for the case when the offsets
don't converge fast enough. We could simply use a pessimistic
solution after a few iterations... */
} while (changed);
}
+void be_emit_entity(ir_entity *entity, bool entity_sign, int offset,
+ bool is_relative)
+{
+ (void) entity;
+ (void) entity_sign;
+ (void) offset;
+ (void) is_relative;
+ panic("not implemented yet");
+}
+
void be_emit_code(FILE *output, const binary_emiter_interface_t *interface)
{
unsigned offset;
for (fragment = first_fragment; fragment != NULL;
fragment = fragment->next) {
unsigned char *jmpbuffer;
+ unsigned nops;
/* assure alignment by emitting nops */
assert(fragment->offset >= offset);
- unsigned nops = fragment->offset - offset;
+ nops = fragment->offset - offset;
if (nops > 0) {
unsigned char *nopbuffer = obstack_alloc(&code_fragment_obst, nops);
interface->create_nops(nopbuffer, nops);