[PATCH] arm reversible : <phase_2_complete>

[oza Pawandeep]

Hi Tom,

I have fixed most of your comments.
as far as formatting is concerned, I am still trying to hard to get it
right. but at the end mailer ends up messing it up :(
following are the comments.

We try not to put FIXME comments into new code.
Nobody ever fixes them.

You can just write an informative comment instead: "We have no way to
read the SPSR value".  Assuming that is accurate.

Oza >> removed FIX ME comments and put appropriate comments.

The enclosing function, arm_record_extension_space, takes care to return
a value, but (1) the meaning of the return value is not documented in
the function's introductory comment (this problems affects many of the
new functions), and (2) the only caller does not check it.

oza >> thanks for pointing that out, I have added descirption and
caler must be checking return value which I have corrected.

What happens if the user hits an instruction which is not handled?
Right now a message is printed.  But shouldn't it abort the operation in
some other way?  That is, is emitting a message really sufficient?

Oza >> I have chaged the description a bit, the abort message is
printed, but at the same time return value is -1, which will cause gdb
standard stack unwinding, with error(...) symentics.


Formatting looks weird.
A typedef for the function type would probably make this look less
strange.

oza >> converted to typedef defination, it looks simpler now.

No need for this backslash.

Oza >> removed.


oza> +  if (arm_record.arm_regs)
oza> +    xfree (arm_record.arm_regs);
oza> +  if (arm_record.arm_mems)
oza> +    xfree (arm_record.arm_mems);

This is fine as long as you have proved that nothing in any possible
call path here can throw an exception.  If anything throws an exception,
then you are leaking memory and should instead use a cleanup.



Oza >> I have added a new function deallocate_reg_arm....
the design is in such a way, that any function goes for allocation
until and unless it supports the insn; otherwise memory is always
local/cache, so in case of exception it simply unwinds wihtout
affecting dymanic memory.
and in case we have allocated memory, we make sure that we come to the
end of the process_record funntion and we free them irrespective of
success or failure;

oza> +   /* Parse swi insn args, sycall record.  */
oza> +  int (*arm_swi_record) (struct regcache *regcache);

Since this is only used in your Phase 3 patch, it belongs there.

Oza >> In my thinking, it was necessary to add this function pointer
because I had already added logic of decoding insn in phase 2, where I
am just checking if this fp is NULL.
where this fp was initialised to NULL, which will be replaced with
valid fp in phase 3.
wihtout including this, phase 2 would have missed on insn decoding.



Regards,
Oza.


On Fri, Nov 18, 2011 at 2:10 AM, Tom Tromey <tromey@redhat.com> wrote:
>>>>>> "oza" == oza Pawandeep <oza.pawandeep@gmail.com> writes:
>
> oza> please find the latest patch below.
>
> No ChangeLog entry.
>
> No NEWS entry.
>
> Patch got mangled by your mailer again.
>
> oza> +        memcpy(&REGS[0],&RECORD_BUF[0],sizeof(uint32_t)*LENGTH); \
>
> Wrong spacing.
>
> oza> +        memcpy(&MEMS->len,&RECORD_BUF[0],sizeof(struct arm_mem_r) * LENGTH); \
>
> Likewise.
>
> oza> +}arm_record_strx_t;
>
> Spacing.
>
> oza> +}record_type_t;
>
> Again.
>
> oza> +
> oza> +static int
> oza> +arm_record_strx (insn_decode_record *arm_insn_r, uint32_t *record_buf,
> oza> +    uint32_t *record_buf_mem, arm_record_strx_t str_type)
>
> Indentation.
>
> oza> +   if ((14 == arm_insn_r->opcode) || (10 == arm_insn_r->opcode))
>
> Too many parens.
>
> oza> +  else if ((12 == arm_insn_r->opcode) || (8 == arm_insn_r->opcode))
>
> Again.
>
> oza> +  else if ((11 == arm_insn_r->opcode) || (15 == arm_insn_r->opcode)
> oza> +    || (2 == arm_insn_r->opcode) || (6 == arm_insn_r->opcode))
>
> Again, plus indentation.
>
> oza> +      regcache_raw_read_unsigned (reg_cache, reg_src1
> oza> +                                 , &u_regval[0]);
>
> Formatting -- "," is on the wrong line.
>
> I see most of these issues multiple times.  Please go over the entire
> patch and fix them all.  I feel like I asked this before.
>
> oza> +                  /* FIX ME: How to read SPSR value?  */
>
> We try not to put FIXME comments into new code.
> Nobody ever fixes them.
>
> You can just write an informative comment instead: "We have no way to
> read the SPSR value".  Assuming that is accurate.
>
> The enclosing function, arm_record_extension_space, takes care to return
> a value, but (1) the meaning of the return value is not documented in
> the function's introductory comment (this problems affects many of the
> new functions), and (2) the only caller does not check it.
>
> What happens if the user hits an instruction which is not handled?
> Right now a message is printed.  But shouldn't it abort the operation in
> some other way?  That is, is emitting a message really sufficient?
>
> oza> +/* Decode arm/thumb insn depending on condition cods and opcodes; and
> oza> dispatch it.  */
> oza> +
> oza> +static int
> oza> +decode_insn (insn_decode_record *arm_record, record_type_t record_type,
> oza> +                uint32_t insn_size)
>
> E.g., here the return value should be documented.
>
> oza> +  static int (*const arm_handle_insn[8])
> oza> +                                      (insn_decode_record*) =
>
> Formatting looks weird.
> A typedef for the function type would probably make this look less
> strange.
>
> oza> +      /* if this insn has fallen into extension space then we need
> oza> not decode it anymore.  */
> oza> +      if (!INSN_RECORDED(arm_record))
> oza> +        {
> oza> +          arm_handle_insn[insn_id] (arm_record);
>
> ... it seems like there should be a check of the return value here.
> I don't understand this.
>
> oza> +              if (record_arch_list_add_mem \
>
> No need for this backslash.
>
> oza> +                ((CORE_ADDR)arm_record.arm_mems[no_of_rec].addr,
> oza> +                arm_record.arm_mems[no_of_rec].len))
>
> Really messed up formatting.
>
> oza> +  if (arm_record.arm_regs)
> oza> +    xfree (arm_record.arm_regs);
> oza> +  if (arm_record.arm_mems)
> oza> +    xfree (arm_record.arm_mems);
>
> This is fine as long as you have proved that nothing in any possible
> call path here can throw an exception.  If anything throws an exception,
> then you are leaking memory and should instead use a cleanup.
>
> oza> +   /* Parse swi insn args, sycall record.  */
> oza> +  int (*arm_swi_record) (struct regcache *regcache);
>
> Since this is only used in your Phase 3 patch, it belongs there.
>
> Tom
>