Hints for Post-Lab Quiz 1 - PowerPoint PPT Presentation

1 / 26
About This Presentation
Title:

Hints for Post-Lab Quiz 1

Description:

Work out what is needed. Generate the design in C or in pseudo code ... The Rosetta Stone. Engineering version. 68K code .section code; .global _Return1; _Return1: ... – PowerPoint PPT presentation

Number of Views:14
Avg rating:3.0/5.0
Slides: 27
Provided by: enelUc
Category:
Tags: hints | lab | post | quiz | rosetta

less

Transcript and Presenter's Notes

Title: Hints for Post-Lab Quiz 1


1
Hints for Post-Lab Quiz 1
  • Works for other quizzes and exams too

2
Three types of questions
  • Basic Knowledge Questions
  • Translation Questions
  • You are given the C and must convert into
    Blackfin assembly code
  • Design questions
  • Work out what is needed
  • Generate the design in C or in pseudo code
  • Most often convert design code into Blackfin
    assembly code

3
Knowledge type question example
CORRECTOR WRONGANSWERNO PARTIAL
MARKS Sometimes more than one correct
  • Circle and label with an A -- the icon (menu
    item) that causes VisualDSP to compile the C
    code, but not build or rebuild the full project.
  • B) Circle and label with a B -- a Blackfin
    instruction where a non-volatile register is
    recovered from the stack.

4
The Rosetta StoneEngineering version
Demonstrates ability to transfer knowledgeWhich
register is used as the 68K return register?In
this code, which register is used as the 68K
frame pointer?
C code Used asextern C long int Return1( ) long int Return1( ) return 1 Blackfin code .section program .global _Return1 _Return1 LINK 16 R0 1 UNLINK RTS 68K code .section code .global _Return1 _Return1 LINK -16, A4 MOVE.L 1, D0 UNLINK A4 RTS
5
C to assembly Example
ACCURACYIMPORTANT
define count_R1 R1count_R1 0
TRY TO MATCH ASSEMBLY CODE TO C ON A BOX BY BOX
BASIS THEN EASIER TO GIVEPARTIAL MARKS
6
Design question exampleActs like one part of the
laboratory
7
Design Question
  • Next to impossible to mark if not well documented
  • Therefore many marks are given for the C or
    pseudo-code comments
  • More chance of partial marks if the registers are
    self documenting

8
Register documentation example
ID_R1.L lo(CHIPID) //
Marker know thatID_R1.H hi(CHIPID)
// R1 used to store ID CC ID_R1
version_INPAR_R0 // Marker knows that

// R0 used for version// Marker also know
that you know first parameter is passed in R0 //
and not on the stack later if you make a
mistake version_R1then still a good chanace for
partial (or full) mark
9
Avoid errors that would take a lot of time to fix
in the laboratory
  • Always check for possible return address and
    stack errors
  • LINK -- at the start of a function
  • UNLINK -- at the end of a function
  • Always check for NAME_MANGLING
  • Variable _fooarray
  • Function _FeeFunction__Fv (void)
  • _FeeFunction__Fl (long
    int) _FeeFunction__NM (not
    sure) _FeeFunction__NM2
    (different not sure)
  • WITH NAME MANGLING under exam conditions, more
    interested in that you understand the concept
    than whether you are getting it exactly correct

10
Avoid pointer errors that would take a lot of
time to fix in the laboratory
  • If the memory location is shown as extern in C
    or .extern in Assembly
  • extern long int
    funVariable
  • .extern _funVariable
  • .section program // will accept code
  • P0.L _funVariableP0.H _funVariable

11
Avoid pointer errors that would take a lot of
time to fix in the laboratory
  • If the memory location is shown without the word
    EXTERN
  • long int funVariable
    0
  • .section data1 // will accept data, L1_data
  • .global _funVariable
  • .var _funVariable 0 // Follow the C
  • .section program
  • P0.L _funVariableP0.H _funVariable
  • HINT If it is name mangled
    DONT use hi( ) or lo( )

12
Avoid pointer errors that would take a lot of
time to fix in the laboratory
  • If the memory location is known to be part of the
    special MEMORY LOCATIONS (MMR) used to control
    special operations of the Blackfin peripherals
  • include ltdefBF533.hgt // will accept ltdefs
  • include ltmacros.hgt // will accept ltmacro.hgt
  • .section program
  • P0.L lo(TCOUNT) // will accept HI( ) and
    LO ( )P0.H hi(TCOUNT)
  • HINT If it is name mangled
  • DONT use hi( ) or lo( )

13
HINT define CONSTANTSdont use CONSTANTS
  • define MAXVALUE 44000 Either hex or
    decimal is okay
  • .section program
  • R0.L lo(MAXVALUE)R0.H hi(MAXVALUE)
  • HINT If the person is following standard
    coding conventions then CAPITIALS MEAN CONSTANT
    use hi( ), lo( )

14
HINT Will work for small constants too
  • define MAXVALUE 22000 Either hex or
    decimal is okay
  • .section program
  • R0.L lo(MAXVALUE)R0.H hi(MAXVALUE)
  • BUT IN THIS CASE since the constant is small
    (short int size)
  • R0 MAXVALUE
  • Or R0 6
  • HINT If it looks like IT MIGHT BE a big
    constant, then let the assembler worry about it
    -- use hi( ) and lo( )

15
Condition codes
  • 99999 times out of 100000 the following is wrong
  • CC R0 lt number
  • So play the odds
  • R1 number
  • CC R0 lt R1
  • Will accept CC (R0 lt R1)
  • WILL NOT ACCEPT CC R1 gt R0
  • CC conditions are always checked VERY closely as
    they cause so much problem in the laboratory and
    in real life

16
LOAD AND STORE OPERATIONS
  • Rule to remember if the operation would not
    work on the MIPS, then it will not work on the
    Blackfin or any other RISC processor
  • register ? memory R0 P1memory ?
    register P1 R0
  • NEVER add to memory, P1 P0 1 add
    to register R0 R0 P0

17
Register operationsAdd a small number
  • Make sure that you get the common instructions
    correct there are not many
  • R0 pretty_small_number R0 6
    or R0 -10 NOT R0 R0 6
  • Pretty_small_numbers are just that pretty small
    numbers -64 lt num lt 63

18
Register operationsAdd a larger number
  • Make sure that you get the common instructions
    correct there are not many
  • R1 larger_number
  • R0 R0 R1
  • R1 0x2000
  • R0 R0 R1 NOT R0 R1
    R1 20000 R0 R0 R1
  • R1.L lo(40000) R1.H
    hi(40000) R0 R0 R1
  • HINT Hexadecimal numbers are easy to work out
    if they are small (need 16-bits) or very large
    (need 32-bits). Decimal numbers are not PLAY
    THE ODDS if it looks large in decimal then
    use lo( ), hi( ) approach

19
Other instructions we have used
  • Make sure that you get the common instructions
    correct there are not many
  • JUMP LABEL_END // OFTEN JUMP
    (P0) // typically end of function

20
Other instructions we have used
  • Make sure that you get the common instructions
    correct there are not many
  • CALL _FeePassVoidFunction__Fv
    // void FeePassVoidFunction(void)
  • NOTE CALL _FeePassVoidFunction__Fv
    // long int FeePassVoidFunction(vo
    id) // Returns a value in R0

21
Other instructions we have used
  • Make sure that you get the common instructions
    correct there are not many
  • // void FeePassLongIntFunction(long int)
  • CALL _FeePassLongIntFunction__Fl (little
    L) CALL _FeePassLongIntFunction__NM --
    okay in exam
  • CALL _FeePassIntFunction__Fi (little I)
    // void FeePassIntFunction(long int)
  • CALL _FeePassIntFunction__NM2 -- okay in exam

22
Other instructions we have used
  • Make sure that you get the common instructions
    correct there are not many
  • R0 7 CALL _FeeFunction__Fl
    // FeeFunction( )
  • R1 6 R0 7 CALL
    _FumFunction__NM //
    FumFunction(7, 6 )

23
Other instructions we have used
  • Make sure that you get the common instructions
    correct there are not many
  • R0 7 CALL _FeeFunction__Fl
    // FeeFunction( )
  • R1 6 R0 7 CALL
    _FumFunction__NM //
    FumFunction(7, 6 )

24
When to use a register andwhen to use memory
  • .extern _value // extern long int
    value .section L1_data_a .global
    _fum_value // long int fum_value
  • .var _fum_value
  • .section program .global
    _FooFunction__Fl // void FooFunction(long int
    passed_Fickle)
  • _FooFunction__Fl LINK 16
    passed_Fickle_R0 6 //
    passed_Fickle passed_Fickle 6 P0.H
    _value // value
    value 6 P0.L _value R1 P0
    R1 6
  • P0 R1
  • P1.H _fum_value
    // fum_value fum_value 6 P1.L
    _fum_value R2 P1 R2 6
  • P1 R2

  • // Rest of the function

25
When to use a register andwhen to use memory
  • .section program .global
    _FooFunction__Fl // void FooFunction(long int
    passed_Fickle)
  • _FooFunction__Fl LINK 16
    passed_Fickle_R0 6 // passed_Fickle
    passed_Fickle 6 define value_R1 R1
    // long int value value_R1 6
    // value value 6
  • define fum_valueR2 R2 // long int
    fum_value
  • fum_value_R2 6 //
    fum_value fum_value 6

  • // Rest of the function

26
  • Other requested question and answers
Write a Comment
User Comments (0)
About PowerShow.com