RISC-V ಅಸೆಂಬ್ಲರ್‌ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪ್ರಾರಂಭಿಸಲು ನಿಮಗೆ ಬೇಕಾಗಿರುವುದು

ನೀವು ಅಸೆಂಬ್ಲರ್ ಬಗ್ಗೆ ಕುತೂಹಲ ಹೊಂದಿದ್ದರೆ ಮತ್ತು RISC-V ಸರಿಯಾದ ಮಾರ್ಗವೆಂದು ಭಾವಿಸಿದರೆ, ನೀವು ಸರಿಯಾದ ಸ್ಥಳಕ್ಕೆ ಬಂದಿದ್ದೀರಿ. RISC-V ನಲ್ಲಿ ASM ಅನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಅಂದುಕೊಂಡಿದ್ದಕ್ಕಿಂತ ಹೆಚ್ಚು ಕೈಗೆಟುಕುವಂತಿದೆ. ನೀವು ಉಪಕರಣಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡರೆ, ಮಾದರಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮತ್ತು ವಾಸ್ತುಶಿಲ್ಪದ ಕೆಲವು ಪ್ರಮುಖ ನಿಯಮಗಳು.

ಮುಂದಿನ ಸಾಲುಗಳಲ್ಲಿ ನಾನು ಹಲವಾರು ಮೂಲಗಳಲ್ಲಿ ಅತ್ಯುತ್ತಮವಾದವುಗಳನ್ನು ಸಂಯೋಜಿಸಿದ್ದೇನೆ: ಗುರು ಪ್ರಕಾರದ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳೊಂದಿಗೆ ಅಭ್ಯಾಸಗಳು, RV32I ಬೇಸ್ ರೆಪರ್ಟರಿಯ ಸಂಪ್ರದಾಯಗಳು, ಲೂಪ್ ಮತ್ತು ಪುನರಾವರ್ತನೆಯ ಉದಾಹರಣೆಗಳು, ಸಿಸ್ಟಮ್ ಕರೆಗಳು, ಮತ್ತು VHDL ನಲ್ಲಿ RISC-V CPU ವಿನ್ಯಾಸದ ನೋಟ (ALU, ಮೆಮೊರಿ ನಿಯಂತ್ರಣ ಮತ್ತು ಸ್ಟೇಟ್ ಯಂತ್ರದೊಂದಿಗೆ), ಜೊತೆಗೆ ಕ್ರಾಸ್-ಟೂಲ್‌ಚೈನ್ ಮತ್ತು ಲಿಂಕ್ ಮಾಡುವ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ವಿಮರ್ಶೆ.

RISC-V ಅಸೆಂಬ್ಲರ್ ಎಂದರೇನು ಮತ್ತು ಅದು ಯಂತ್ರ ಭಾಷೆಗಿಂತ ಹೇಗೆ ಭಿನ್ನವಾಗಿದೆ?

ಎರಡೂ ಲಗತ್ತಿಸಿದ್ದರೂ ಸಹ ಹಾರ್ಡ್ವೇರ್, ಯಂತ್ರ ಭಾಷೆ ಶುದ್ಧ ಬೈನರಿ (ಒಂದು ಮತ್ತು ಸೊನ್ನೆಗಳು) ಇದನ್ನು CPU ನೇರವಾಗಿ ಅರ್ಥೈಸುತ್ತದೆ, ಆದರೆ ಅಸೆಂಬ್ಲರ್ ಜ್ಞಾಪಕಶಾಸ್ತ್ರವನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಚಿಹ್ನೆಗಳು ಅಸೆಂಬ್ಲರ್ ಗಿಂತ ಹೆಚ್ಚು ಓದಬಲ್ಲವು ನಂತರ ಬೈನರಿ ಆಗಿ ಅನುವಾದಿಸುತ್ತವೆ.

RISC-V ಅತ್ಯಂತ ಸ್ವಚ್ಛವಾದ ಮೂಲ ಸಂಗ್ರಹದೊಂದಿಗೆ ಮುಕ್ತ ISA ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. RV32I (32-ಬಿಟ್) ಪ್ರೊಫೈಲ್ 39 ಬಳಕೆದಾರ ಸೂಚನೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಗಮನಾರ್ಹವಾದ ಆರ್ಥೋಗೋನಾಲಿಟಿಯೊಂದಿಗೆ, ಶುದ್ಧ ಕಂಪ್ಯೂಟೇಶನ್‌ನಿಂದ ಮೆಮೊರಿ ಪ್ರವೇಶವನ್ನು ಬೇರ್ಪಡಿಸುತ್ತದೆ ಮತ್ತು GCC/LLVM ನಲ್ಲಿ ಅತ್ಯುತ್ತಮ ಬೆಂಬಲದೊಂದಿಗೆ.

ದಾಖಲೆಗಳು, ಒಪ್ಪಂದಗಳು ಮತ್ತು ಪ್ರವೇಶ ಬಿಂದು

RV32I ನಲ್ಲಿ ನೀವು 32 ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ ರಿಜಿಸ್ಟರ್‌ಗಳು (x0–x31) 32-ಬಿಟ್; x0 ಅನ್ನು ಯಾವಾಗಲೂ 0 ಎಂದು ಓದಲಾಗುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಬರೆಯಲಾಗುವುದಿಲ್ಲ. a0–a7 (ವಾದಗಳು), t0–t6 (ತಾತ್ಕಾಲಿಕಗಳು), ಅಥವಾ s0–s11 ​​(ಉಳಿಸಲಾಗಿದೆ) ನಂತಹ ಅಲಿಯಾಸ್‌ಗಳು ಸಹ ABI ಅನ್ನು ಅನುಸರಿಸಲು ಉಪಯುಕ್ತವಾಗಿವೆ.

ಪರಿಸರ ಅಥವಾ ಸಿಮ್ಯುಲೇಟರ್ ಅನ್ನು ಅವಲಂಬಿಸಿ, ಪ್ರೋಗ್ರಾಂ ನಿರ್ದಿಷ್ಟ ಲೇಬಲ್‌ನಿಂದ ಪ್ರಾರಂಭವಾಗಬಹುದು. ಗುರು ಗ್ರಹದಲ್ಲಿ, ಕಾರ್ಯಕ್ರಮಗಳು ಜಾಗತಿಕ __start ಟ್ಯಾಗ್‌ನಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ., ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ಗುರುತಿಸಲು ನೀವು ಅದನ್ನು ಗೋಚರಿಸುವಂತೆ ಘೋಷಿಸಬೇಕು (ಉದಾಹರಣೆಗೆ, .globl ನೊಂದಿಗೆ).

ದಿ ಟ್ಯಾಗ್‌ಗಳು ಕೊಲೊನ್‌ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತವೆ, ನೀವು ಪ್ರತಿ ಸಾಲಿಗೆ ಒಂದು ಸೂಚನೆಯನ್ನು ಮಾತ್ರ ಹಾಕಬಹುದು ಮತ್ತು ಕಾಮೆಂಟ್‌ಗಳನ್ನು # ಅಥವಾ ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬಹುದು; ಆದ್ದರಿಂದ ಅಸೆಂಬ್ಲರ್ ಅವುಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸುತ್ತದೆ.

ಪರಿಕರಗಳು ಮತ್ತು ಸಿಮ್ಯುಲೇಟರ್‌ಗಳು: ಗುರು ಮತ್ತು ಮೂಲ ಕಾರ್ಯಪ್ರವಾಹ

ತೊಡಕುಗಳಿಲ್ಲದೆ ಅಭ್ಯಾಸ ಮಾಡಲು, ನೀವು ಗುರು ಸಿಮ್ಯುಲೇಟರ್/ಜೋಡಿಸುವವನು, SPIM/MARS/VENUS ನಿಂದ ಪ್ರೇರಿತವಾದ ಗ್ರಾಫಿಕಲ್ ಪರಿಕರವಾಗಿದ್ದು, ಒಂದೇ ಪರಿಸರದಲ್ಲಿ ಸಂಪಾದನೆ, ಜೋಡಣೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ.

ಗುರುಗ್ರಹದಲ್ಲಿ ನೀವು ಸಂಪಾದಕ ಟ್ಯಾಬ್‌ನಲ್ಲಿ ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು, ಸಂಪಾದಿಸಬಹುದು ಮತ್ತು ಅಳಿಸಬಹುದು. ಉಳಿಸಿದ ನಂತರ, F3 ನೊಂದಿಗೆ ಜೋಡಿಸಿ ಮತ್ತು ಚಲಾಯಿಸಿ ಯಂತ್ರದ ಸ್ಥಿತಿಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ರಿಜಿಸ್ಟರ್ ಮತ್ತು ಮೆಮೊರಿ ವೀಕ್ಷಣೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸೂಚನೆಯ ಮೂಲಕ ಹರಿವಿನ ಸೂಚನೆಯನ್ನು ಡೀಬಗ್ ಮಾಡಲು.

ಕಾರ್ಯಕ್ರಮಗಳು ಪರಿಸರಕ್ಕೆ ಕರೆಯೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳಬೇಕು: ಕೋಡ್ 10 ನೊಂದಿಗೆ ಕರೆ ಸೆಟ್ಟಿಂಗ್ a0 ನಿಂದ ನಿರ್ಗಮಿಸಿ (ನಿರ್ಗಮನ). RISC-V ನಲ್ಲಿ, ಇ-ಕಾಲ್‌ಗಳು ಸಿಸ್ಟಮ್ ಕರೆಗಳಿಗೆ ಅಥವಾ ಪರಿಸರ/ವ್ಯವಸ್ಥೆಗೆ ಬಲೆಗಳಿಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ.

ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ಸಿಸ್ಟಮ್ ಕರೆಗಳ ಕನಿಷ್ಠ ರಚನೆ

ಶೈಕ್ಷಣಿಕ ಉದಾಹರಣೆಗಳಲ್ಲಿನ ವಿಶಿಷ್ಟ ರಚನೆಯು ಆರಂಭಿಕ ಹಂತವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಕೆಲಸವನ್ನು ಮಾಡುತ್ತದೆ ಮತ್ತು ಇ-ಕಾಲ್‌ನೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಇಕಾಲ್ ವಾದಗಳು ಸಾಮಾನ್ಯವಾಗಿ a0–a2 ನಲ್ಲಿ ಚಲಿಸುತ್ತವೆ. ಮತ್ತು ಪರಿಸರವನ್ನು ಅವಲಂಬಿಸಿ a7 ನಲ್ಲಿ ಸೇವಾ ಆಯ್ಕೆದಾರ.

ಎ ಲಿನಕ್ಸ್ ಉದಾಹರಣೆಗೆ, RISC-V ನಲ್ಲಿ ನೀವು syscall ಬರೆಯುವ ಮೂಲಕ ಮುದ್ರಿಸಬಹುದು ಮತ್ತು ಸೂಕ್ತವಾದ ಕೋಡ್‌ನೊಂದಿಗೆ ನಿರ್ಗಮಿಸಬಹುದು. ಬರೆಯಲು a0 (fd), a1 (ಬಫರ್), a2 (ಉದ್ದ) ಮತ್ತು a7 ಗಳನ್ನು ಸೇವಾ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ.ಅಂತಿಮವಾಗಿ, a0 ಅನ್ನು ರಿಟರ್ನ್ ಕೋಡ್‌ಗೆ ಮತ್ತು a7 ಅನ್ನು ನಿರ್ಗಮನ ಸಂಖ್ಯೆಗೆ ಹೊಂದಿಸಲಾಗಿದೆ.

# Ejemplo mínimo (Linux RISC-V) para escribir y salir
.global _start
_start:
  addi a0, x0, 1        # fd = 1 (stdout)
  la   a1, msg          # a1 = &msg
  addi a2, x0, 12       # a2 = longitud
  addi a7, x0, 64       # write
  ecall

  addi a0, x0, 0        # return code
  addi a7, x0, 93       # exit
  ecall

.data
msg: .ascii "Hola mundo\n"

ನೀವು ಲಿನಕ್ಸ್ ಹೊರಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಉದಾಹರಣೆಗೆ ತಮ್ಮದೇ ಆದ IoT ಸೇವೆಯೊಂದಿಗೆ ಶೈಕ್ಷಣಿಕ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳು, ಪರಿಸರ ದಸ್ತಾವೇಜನ್ನು ಪ್ರಕಾರ ಇಕಾಲ್ ಸಂಖ್ಯೆ ಮತ್ತು ನೋಂದಣಿಗಳನ್ನು ಬದಲಾಯಿಸಿ.

ಕಂಡಿಷನಲ್‌ಗಳು, ಲೂಪ್‌ಗಳು ಮತ್ತು ಮೆಮೊರಿಯೊಂದಿಗೆ ಆರಾಮದಾಯಕವಾಗಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುವ ಆರಂಭಿಕ ವ್ಯಾಯಾಮಗಳು.

ಒಂದು ಪೂರ್ಣಾಂಕವು ಋಣಾತ್ಮಕವಾಗಿದೆಯೇ ಎಂದು ಕಂಡುಹಿಡಿಯುವುದು ಒಂದು ವಿಶಿಷ್ಟವಾದ ಅಭ್ಯಾಸವಾಗಿದೆ. ಅದು ಧನಾತ್ಮಕವಾಗಿದ್ದರೆ ನೀವು 0 ಅನ್ನು ಮತ್ತು ಋಣಾತ್ಮಕವಾಗಿದ್ದರೆ 1 ಅನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದು.; RV32I ಜೊತೆಗೆ, 0 ಮತ್ತು ಸೆಟ್-ಆನ್-ಕಡಿಮೆ-ದಾನ್ ಜೊತೆ ಹೋಲಿಕೆ ಮಾಡುವುದರಿಂದ ಒಂದೇ ಚೆನ್ನಾಗಿ ಯೋಚಿಸಿದ ಸೂಚನೆಯಲ್ಲಿ ಸಮಸ್ಯೆ ಬಗೆಹರಿಯುತ್ತದೆ.

ಒಂದು ಸಂಖ್ಯೆಯ ಅಪವರ್ತನಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದು ಮತ್ತೊಂದು ಉಪಯುಕ್ತ ವ್ಯಾಯಾಮ: 1 ರಿಂದ n ವರೆಗೆ ಅಡ್ಡಹಾಯುತ್ತದೆ, ಭಾಜಕಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು ಎಷ್ಟು ಇದ್ದವು ಎಂಬುದನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆನೀವು ಷರತ್ತುಬದ್ಧ ಶಾಖೆಗಳು, ಭಾಗಾಕಾರ (ಅಥವಾ ಪುನರಾವರ್ತಿತ ವ್ಯವಕಲನ), ಮತ್ತು ಸಂಕಲನ ಮತ್ತು ಹೋಲಿಕೆಯೊಂದಿಗೆ ಕುಣಿಕೆಗಳನ್ನು ಅಭ್ಯಾಸ ಮಾಡುತ್ತೀರಿ.

ತಂತಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದರಿಂದ ನೀವು ಸ್ಮರಣೆಯನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ: ಮೆಮೊರಿಯಲ್ಲಿರುವ ಸ್ಟ್ರಿಂಗ್‌ನ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರವನ್ನು ಭೇಟಿ ಮಾಡಿ ಮತ್ತು ಇನ್-ಪ್ಲೇಸ್‌ನಲ್ಲಿ ಸಣ್ಣಕ್ಷರವನ್ನು ದೊಡ್ಡಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸಿ. ಅವು ASCII ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಹೊಂದಿಕೆಯಾದರೆ. ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಅದು ಸ್ಟ್ರಿಂಗ್‌ನ ಮೂಲ ವಿಳಾಸವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಕುಣಿಕೆಗಳು, ಕಾರ್ಯಗಳು ಮತ್ತು ಪುನರಾವರ್ತನೆ: ಅಪವರ್ತನೀಯ, ಫಿಬೊನಾಚಿ ಮತ್ತು ಹನೋಯಿ ಗೋಪುರ

ಲೂಪ್‌ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ, ಮೂರು ಬ್ಲಾಕ್‌ಗಳ ಬಗ್ಗೆ ಯೋಚಿಸಿ: ಸ್ಥಿತಿ, ದೇಹ ಮತ್ತು ಹಂತ. beq/bne/bge ಮತ್ತು ಷರತ್ತುಬದ್ಧ ಜಿಗಿತಗಳೊಂದಿಗೆ jal/j while/for ನಿರ್ಮಿಸಲಾಗಿದೆ ನಿಗೂಢತೆ ಇಲ್ಲದೆ, ಹೆಚ್ಚುವರಿ ಮತ್ತು ಹೋಲಿಕೆಗಳನ್ನು ಅವಲಂಬಿಸಿದೆ.

.text
.globl __start
__start:
  li t0, 0        # i
  li t1, 10       # max
cond:
  bge t0, t1, end # si i >= max, salta
  # cuerpo: usar a0/a1 segun servicio IO del entorno
  addi t0, t0, 1  # i++
  j cond
end:
  li a0, 10
  ecall

ಕಾರ್ಯ ಕರೆಗಳಲ್ಲಿ, ABI ಅನ್ನು ಗೌರವಿಸಿ: ನೀವು ಹೆಚ್ಚಿನ ಕರೆಗಳನ್ನು ಸರಪಳಿ ಮಾಡಲು ಹೋದರೆ ಉಳಿಸಿ., ನೀವು ಅವುಗಳನ್ನು ಮಾರ್ಪಡಿಸಿದರೆ s0–s11 ​​ಅನ್ನು ಸಂರಕ್ಷಿಸುತ್ತದೆ ಮತ್ತು ಪದದ ಗುಣಾಕಾರಗಳಲ್ಲಿ ಚಲಿಸುವ sp ನೊಂದಿಗೆ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.

ಫ್ಯಾಕ್ಟೋರಿಯಲ್ ಎಂಬುದು ಕ್ಲಾಸಿಕ್ ಪುನರಾವರ್ತನೆಯಾಗಿದೆ: ಮೂಲ ಪ್ರಕರಣ n==0 1 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, factorial(n-1) ಅನ್ನು ಕರೆ ಮಾಡಿ ಮತ್ತು n ನಿಂದ ಗುಣಿಸಿ. ಕರೆಯ ಮೊದಲು ಸ್ಟ್ಯಾಕ್‌ನಲ್ಲಿ ಉಳಿಸಲಾದ ra ಮತ್ತು ರೆಜಿಸ್ಟರ್‌ಗಳನ್ನು ರಕ್ಷಿಸಿ ಮತ್ತು ಹಿಂತಿರುಗಿದ ನಂತರ ಅವುಗಳನ್ನು ಪುನಃಸ್ಥಾಪಿಸಿ.

factorial:
  beq a0, x0, base
  addi sp, sp, -8
  sw   ra, 4(sp)
  sw   s0, 0(sp)
  mv   s0, a0
  addi a0, a0, -1
  jal  factorial
  mul  a0, a0, s0
  lw   s0, 0(sp)
  lw   ra, 4(sp)
  addi sp, sp, 8
  jr   ra
base:
  li a0, 1
  jr ra

ಎರಡನ್ನೂ ಅಭ್ಯಾಸ ಮಾಡಲು ಫಿಬೊನಾಚಿ ಉಪಯುಕ್ತವಾಗಿದೆ ಎರಡು ಕರೆಗಳೊಂದಿಗೆ ಪುನರಾವರ್ತನೆ ಸಂಚಯಕ ಅಸ್ಥಿರಗಳೊಂದಿಗೆ ಪರಿಣಾಮಕಾರಿ ಪುನರಾವರ್ತಿತ ಆವೃತ್ತಿಯಾಗಿ. ಮತ್ತು ನೀವು ಹರಿವು ಮತ್ತು ನಿಯತಾಂಕ ನಿಯಂತ್ರಣ ಸವಾಲನ್ನು ಬಯಸಿದರೆ, ಪರಿಹಾರವನ್ನು ಅಸೆಂಬ್ಲರ್‌ಗೆ ಅನುವಾದಿಸಿ. ಹನೋಯ್ ಗೋಪುರಗಳು ನಾಲ್ಕು ವಾದಗಳೊಂದಿಗೆ: ಡಿಸ್ಕ್‌ಗಳು, ಮೂಲ, ಗಮ್ಯಸ್ಥಾನ ಮತ್ತು ಸಹಾಯಕ ಗೋಪುರ; ಇದು ಕರೆ ಕ್ರಮವನ್ನು ಗೌರವಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಯೊಂದು ಚಲನೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಮೆಮೊರಿ ಪ್ರವೇಶ, ಅರೇಗಳು ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಕುಶಲತೆ

RISC-V ನಲ್ಲಿ, ಮೆಮೊರಿ ಪ್ರವೇಶವನ್ನು ಲೋಡ್/ಸ್ಟೋರ್‌ನೊಂದಿಗೆ ಮಾಡಲಾಗುತ್ತದೆ: ಪದಗಳಿಗೆ lw/sw, ಅರ್ಧಪದಗಳಿಗೆ lh/sh, ಮತ್ತು ಬೈಟ್‌ಗಳಿಗೆ lb/sb, ಶುಲ್ಕಗಳಲ್ಲಿ ಸಹಿ ಮಾಡಿದ ಅಥವಾ ಸಹಿ ಮಾಡದ ರೂಪಾಂತರಗಳೊಂದಿಗೆ (lb vs lbu, lh vs lhu).

ಪೂರ್ಣಾಂಕ ಶ್ರೇಣಿಗಳನ್ನು ಹಾದುಹೋಗಲು, ಪ್ರತಿ ಸೂಚ್ಯಂಕಕ್ಕೆ 4-ಬೈಟ್ ಆಫ್‌ಸೆಟ್‌ಗಳನ್ನು ಬಳಸಿ; ಪಠ್ಯ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗಾಗಿ, ಟರ್ಮಿನೇಟರ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯುವವರೆಗೆ ಬೈಟ್ ಬೈಟ್ ಅನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ ಸಂಪ್ರದಾಯವು ಅದನ್ನು ಅಗತ್ಯವಿದ್ದರೆ (ಉದಾ., \0). ಮೂಲ ವಿಳಾಸಗಳನ್ನು ಉಳಿಸಲು ಮತ್ತು ಸೂಕ್ತವಾಗಿ addi/auipc/la ನೊಂದಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮರೆಯದಿರಿ.

ಮೊದಲಿನಿಂದ RV32I CPU ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದು: ಉನ್ನತ ಮಟ್ಟದ ಅವಲೋಕನ.

ನೀವು ಸಿಲಿಕಾನ್‌ಗೆ ಇಳಿಯಬೇಕೆಂದು ಭಾವಿಸಿದರೆ, ಶೈಕ್ಷಣಿಕ ಯೋಜನೆಯು VHDL ನಲ್ಲಿ RV32I CPU, FPGA ನಲ್ಲಿ ಸಂಶ್ಲೇಷಿಸಬಹುದಾಗಿದೆ. ಕಡಿಮೆ-ಮಧ್ಯಮ ಶ್ರೇಣಿ. ಪ್ರೋಗ್ರಾಂ ROM, ಡೇಟಾ RAM ಮತ್ತು LED ಬೆಳಗಿಸಲು ಸರಳ GPIO ಅನ್ನು ಒಳಗೊಂಡಿದೆ.

ಕರ್ನಲ್ ಮೂಲ ರೆಪರ್ಟರಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ (M/A/C ವಿಸ್ತರಣೆಗಳು ಅಥವಾ CSR ಗಳಿಲ್ಲದೆ), 32-ಬಿಟ್ ವಿಳಾಸ ಬಸ್ ಅನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಸೂಕ್ತವಾದಲ್ಲಿ 8-/16-/32-ಬಿಟ್ ಸೈನ್-ಎಕ್ಸ್‌ಟೆಂಡೆಡ್ ಮೆಮೊರಿ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ವಿನ್ಯಾಸವು ರಿಜಿಸ್ಟರ್‌ಗಳು, ALU, ಮೆಮೊರಿ ನಿಯಂತ್ರಕ ಮತ್ತು ಸ್ಟೇಟ್ ಮೆಷಿನ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ.

ALU, ವರ್ಗಾವಣೆಗಳು ಮತ್ತು "ವಿಳಂಬಿತ ಲೋಡಿಂಗ್" ಕಲ್ಪನೆ

ALU ಅನ್ನು ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ ವಿವರಿಸಲಾಗಿದೆ, ಉದಾಹರಣೆಗೆ ಸಂಕಲನ, ವ್ಯವಕಲನ, XOR, OR, AND, ಹೋಲಿಕೆಗಳು (ಸಹಿ ಮಾಡಿದ ಮತ್ತು ಸಹಿ ಮಾಡದ) ಮತ್ತು ತಾರ್ಕಿಕ/ಅಂಕಗಣಿತದ ಬದಲಾವಣೆಗಳು.

FPGA ನಲ್ಲಿ LUT ಗಳನ್ನು ಉಳಿಸಲು, ಮಲ್ಟಿ-ಬಿಟ್ ಶಿಫ್ಟ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ನಿಂದ ನಿಯಂತ್ರಿಸಲ್ಪಡುವ 1-ಬಿಟ್ ಶಿಫ್ಟ್‌ಗಳನ್ನು ಪುನರಾವರ್ತಿಸುವುದು: ನೀವು ಹಲವಾರು ಚಕ್ರಗಳನ್ನು ಬಳಸುತ್ತೀರಿ, ಆದರೆ ನೀವು ತಾರ್ಕಿಕ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತೀರಿ.

ಸಿಂಕ್ರೊನಸ್ ಸರ್ಕ್ಯೂಟ್‌ಗಳಲ್ಲಿ, ಗಡಿಯಾರದ ಅಂಚುಗಳಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ಗಮನಿಸಬಹುದು. "ವಿಳಂಬಿತ ಲೋಡ್" ಎಂಬ ಪರಿಕಲ್ಪನೆಯು ಮಲ್ಟಿಪ್ಲೆಕ್ಸರ್‌ನಿಂದ ಆಯ್ಕೆ ಮಾಡಲ್ಪಟ್ಟದ್ದು ಮುಂದಿನ ಚಕ್ರದಲ್ಲಿ ರಿಜಿಸ್ಟರ್ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿಸುತ್ತದೆ., ಫೆಚ್-ಡಿಕೋಡ್-ಎಕ್ಸಿಕ್ಯೂಟ್ ಸ್ಟೇಟ್ ಮೆಷಿನ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ ಪ್ರಮುಖ ಅಂಶವಾಗಿದೆ.

ಮೆಮೊರಿ ನಿಯಂತ್ರಕ ಮತ್ತು ನಕ್ಷೆ: ROM, RAM ಮತ್ತು GPIO

ಒಂದು ಮೆಮೊರಿ ಬ್ಲಾಕ್ ROM ಮತ್ತು RAM ಅನ್ನು ಪಕ್ಕದ ಜಾಗಕ್ಕೆ ಸಂಯೋಜಿಸುತ್ತದೆ, ಪ್ರೊಸೆಸರ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಸರಳಗೊಳಿಸುವುದುನಿಯಂತ್ರಕವು AddressIn (32 ಬಿಟ್‌ಗಳು), DataIn, ಅಗಲ (ಬೈಟ್/ಅರ್ಧ/ಪದ), ಸೈನ್ ಎಕ್ಸ್‌ಟೆನ್ಶನ್ ಸಿಗ್ನಲ್, WE (ಓದಲು/ಬರೆಯಲು), ಮತ್ತು Start to initiate ವಹಿವಾಟುಗಳನ್ನು ಪಡೆಯುತ್ತದೆ.

ಕಾರ್ಯಾಚರಣೆ ಮುಗಿದಾಗ, ReadyOut ಅನ್ನು 1 ಕ್ಕೆ ಹೊಂದಿಸಲಾಗಿದೆ ಮತ್ತು ಅದನ್ನು ಓದಿದ್ದರೆ, ಡೇಟಾಔಟ್ ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿದೆ (ವಿನಂತಿಸಿದಾಗ ಸೈನ್-ವಿಸ್ತರಿಸಲಾಗುತ್ತದೆ). ಅದನ್ನು ಬರೆಯಲಾಗಿದ್ದರೆ, ಡೇಟಾ RAM ನಲ್ಲಿ ಉಳಿಯುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ನಕ್ಷೆಯ ಉದಾಹರಣೆ: 0x0000 ರಿಂದ 0x0FFF ವರೆಗೆ ROM, 0x1000 ನಲ್ಲಿ GPIO ಬೈಟ್ (ಪಿನ್‌ಗೆ ಬಿಟ್ 0) ಮತ್ತು RAM 0x1001 ರಿಂದ 0x1FFF ವರೆಗೆಇದರೊಂದಿಗೆ ನೀವು ಔಟ್‌ಪುಟ್ ಬಿಟ್ ಅನ್ನು ಬರೆಯುವ ಮತ್ತು ಟಾಗಲ್ ಮಾಡುವ ಮೂಲಕ ಬ್ಲಿಂಕರ್ ಮಾಡಬಹುದು.

ರಿಜಿಸ್ಟರ್‌ಗಳು, ಮಲ್ಟಿಪ್ಲೆಕ್ಸರ್‌ಗಳು ಮತ್ತು ರಾಜ್ಯ ಯಂತ್ರಗಳು

CPU, VHDL ನಲ್ಲಿ ಅರೇಗಳೊಂದಿಗೆ ನಿದರ್ಶನಗೊಂಡ 32 ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ ರೆಜಿಸ್ಟರ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಜೊತೆಗೆ ಡಿಕೋಡರ್ ALU ನಿಂದ ಬರೆಯುವ ಗಮ್ಯಸ್ಥಾನವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಮತ್ತು ಉಳಿದದ್ದನ್ನು ಇರಿಸಿಕೊಳ್ಳಲು.

ಮಲ್ಟಿಪ್ಲೆಕ್ಸರ್‌ಗಳು ALU ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ನಿಯಂತ್ರಿಸುತ್ತವೆ (ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಕಾರ್ಯಾಚರಣೆ), ಮೆಮೊರಿ ನಿಯಂತ್ರಕಕ್ಕೆ ಸಂಕೇತಗಳು (ಅಗಲಗಳು, ವಿಳಾಸ, ಪ್ರಾರಂಭ ನಿಯಂತ್ರಣ ಮತ್ತು ಓದು/ಬರೆಯುವಿಕೆ) ಮತ್ತು ವಿಶೇಷ ರೆಜಿಸ್ಟರ್‌ಗಳು: PC, IR ಮತ್ತು ಪುನರಾವರ್ತಿತ ವರ್ಗಾವಣೆಗಳಿಗಾಗಿ ಸಹಾಯಕ ಕೌಂಟರ್.

ರಾಜ್ಯ ಯಂತ್ರವು ಇದರೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮರುಹೊಂದಿಸಿ, PC ಸೂಚಿಸಿದ ಸೂಚನೆಯನ್ನು ಪಡೆಯುತ್ತದೆ (4-ಬೈಟ್ ಓದುವಿಕೆ), ಸಿದ್ಧವಾದಾಗ ಅದನ್ನು IR ಗೆ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಎಕ್ಸಿಕ್ಯೂಶನ್ ನೋಡ್‌ಗಳಿಗೆ ರವಾನಿಸಲಾಗುತ್ತದೆ: ALU (ಶಿಫ್ಟ್‌ಗಳನ್ನು ಹೊರತುಪಡಿಸಿ 1 ಸೈಕಲ್‌ನಲ್ಲಿ ಒಂದು ಸೂಚನೆ), ಲೋಡ್/ಸ್ಟೋರ್, ಶಾಖೆಗಳು ಮತ್ತು ಜಂಪ್‌ಗಳು, ಇಬ್ರೇಕ್‌ನಂತಹ ವಿಶೇಷ ಸೂಚನೆಗಳ ಜೊತೆಗೆ.

ಕ್ರಾಸ್-ಟೂಲ್‌ಚೈನ್, ಲಿಂಕ್ ಮಾಡುವುದು ಮತ್ತು ಡೀಬಗ್ ಮಾಡುವುದು

RV32I ಬೈನರಿಗಳನ್ನು ಉತ್ಪಾದಿಸಲು, ಕ್ರಾಸ್ GCC (ಗುರಿ riscv32-none-elf). ನೀವು C/C++/ASM ಮೂಲಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡಿ, ಮೆಮೊರಿ ನಕ್ಷೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಲಿಂಕ್ ಮಾಡಿ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಅನ್ನು ನಿಮ್ಮ ROM/FPGA ನಿರೀಕ್ಷಿಸುವ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಿ.

ಸರಳವಾದ ಹುಕ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಇರಿಸಬಹುದು 0x0000 ರಿಂದ ROM ನಲ್ಲಿ .ಪಠ್ಯ ಮತ್ತು 0x1004 ರಿಂದ RAM ನಲ್ಲಿ .data (0x1000–0x1003 ಅನ್ನು GPIO ರಿಜಿಸ್ಟರ್‌ಗಳು ಆಕ್ರಮಿಸಿಕೊಂಡಿದ್ದರೆ). ಆರಂಭಿಕ ದಿನಚರಿಯನ್ನು "ನೇಕ್" ಮಾಡಬಹುದು ಮತ್ತು ಇರಿಸಬಹುದು RAM ನ ಕೊನೆಯಲ್ಲಿ ಸ್ಟ್ಯಾಕ್ ಪಾಯಿಂಟರ್ (ಉದಾ. 0x1FFC) ಮುಖ್ಯ ಕರೆ ಮಾಡುವ ಮೊದಲು.

/* Mapa simple
 * ROM: 0x00000000 - 0x00000FFF
 * GPIO: 0x00001000 - 0x00001003
 * RAM: 0x00001004 - 0x00001FFF
 */
SECTIONS {
  . = 0x00000000;
  .text : { *(.startup) *(.text) *(.text.*) *(.rodata*) }
  . = 0x00001004;
  .data : { *(.data) *(.data.*) }
}

riscv32-none-elf-objdump ನೊಂದಿಗೆ ನೀವು ELF ಅನ್ನು ಡಿಸ್ಅಸೆಂಬಲ್ ಮಾಡಿ ಮತ್ತು ವಿಳಾಸಗಳನ್ನು ಪರಿಶೀಲಿಸಿ; ಉದಾಹರಣೆಗೆ, ನೀವು ನೋಡುತ್ತೀರಿ ಬೂಟ್ lui/addi/jal ನಂತಹ ಸೂಚನೆಗಳೊಂದಿಗೆ ಮತ್ತು ನಿಮ್ಮ ಮುಖ್ಯಕ್ಕೆ ಪರಿವರ್ತನೆಯೊಂದಿಗೆ 0x00000000 ನಲ್ಲಿ. VHDL ಸಿಮ್ಯುಲೇಶನ್‌ಗಾಗಿ, GHDL ನೀವು GtkWave ನೊಂದಿಗೆ ತೆರೆಯಬಹುದಾದ ಟ್ರೇಸ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಸಿಮ್ಯುಲೇಶನ್‌ನಲ್ಲಿ ಪರಿಶೀಲಿಸಿದ ನಂತರ, ವಿನ್ಯಾಸವನ್ನು FPGA (ಕ್ವಾರ್ಟಸ್ ಅಥವಾ ಇತರ ಟೂಲ್‌ಚೈನ್) ಗೆ ಕೊಂಡೊಯ್ಯಿರಿ. RAM ಅನ್ನು ಆಂತರಿಕ ಬ್ಲಾಕ್‌ಗಳಾಗಿ ಊಹಿಸಿದರೆ ಮತ್ತು ಕೋಡ್ ಸ್ಪಷ್ಟ RTL ಆಗಿದ್ದರೆ, ಅನುಭವಿ ಸಾಧನಗಳಲ್ಲಿಯೂ ಸಹ, ನೀವು ಆಶ್ಚರ್ಯಗಳಿಲ್ಲದೆ ಸಂಶ್ಲೇಷಿಸಬೇಕು.

ಪ್ರಾರಂಭಿಸುವಾಗ ಪ್ರಾಯೋಗಿಕ ಜ್ಞಾಪನೆಗಳು ಮತ್ತು ವಿಶಿಷ್ಟ ತಪ್ಪುಗಳು

ಅದನ್ನು ಮರೆಯಬೇಡಿ x0 ಯಾವಾಗಲೂ ಶೂನ್ಯವಾಗಿರುತ್ತದೆ.; ಅದಕ್ಕೆ ಬರೆಯುವುದರಿಂದ ಯಾವುದೇ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ, ಮತ್ತು ಅದನ್ನು ಓದುವುದರಿಂದ 0 ಬರುತ್ತದೆ. ಸೇರ್ಪಡೆಗಳು, ಹೋಲಿಕೆಗಳು ಮತ್ತು ನೋಂದಾವಣೆ ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆಗಳಲ್ಲಿ ಇದನ್ನು ನಿಮ್ಮ ಅನುಕೂಲಕ್ಕೆ ಬಳಸಿಕೊಳ್ಳಿ.

ನೀವು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ, ನೀವು ಮಾರ್ಪಡಿಸುವ ra ಮತ್ತು sN ದಾಖಲೆಗಳನ್ನು ಉಳಿಸಿ., ಮತ್ತು sp ಗೆ ಪದ-ಜೋಡಣೆ ಮಾಡಿದ ಸೇರ್ಪಡೆ/ವ್ಯವಕಲನಗಳೊಂದಿಗೆ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಹಿಂತಿರುಗಿದ ನಂತರ, ಅದು ಹಿಮ್ಮುಖ ಕ್ರಮದಲ್ಲಿ ಪುನಃಸ್ಥಾಪಿಸುತ್ತದೆ ಮತ್ತು jr ra ನೊಂದಿಗೆ ಜಿಗಿಯುತ್ತದೆ.

ಗುರು ಗ್ರಹದಂತಹ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳಲ್ಲಿ, ಅದನ್ನು ಪರಿಶೀಲಿಸಿ __start ಜಾಗತಿಕವಾಗಿದೆ ಮತ್ತು ನೀವು ಅದನ್ನು ecall ನೊಂದಿಗೆ ಕೊನೆಗೊಳಿಸುತ್ತೀರಿ. ಸರಿ (ನಿರ್ಗಮಿಸಲು a0=10). ಏನಾದರೂ ಪ್ರಾರಂಭವಾಗದಿದ್ದರೆ, ಲೇಬಲ್, ಜಾಗತಿಕತೆಯನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಮರುಸಂಕಲನ ಮಾಡಿ (F3).

IO ಜೊತೆಗಿನ ವ್ಯಾಯಾಮಗಳಲ್ಲಿ, ಪರಿಸರದ ಶಿಷ್ಟಾಚಾರವನ್ನು ಗೌರವಿಸಿ: ಯಾವ ರಿಜಿಸ್ಟರ್‌ಗಳು ನಿಯತಾಂಕಗಳು, ಸೇವಾ ಸಂಖ್ಯೆ ಮತ್ತು ವಿಳಾಸ ಅಥವಾ ತಕ್ಷಣದ ಮೌಲ್ಯವನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆಯೇ ಎಂಬುದನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಸಿಮ್ಯುಲೇಟರ್ ಅಥವಾ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ದಸ್ತಾವೇಜನ್ನು ಬಳಸಿ.

ಸ್ಪಷ್ಟವಾದ ISA ಬೇಸ್ (RV32I, ರಿಜಿಸ್ಟರ್‌ಗಳು ಮತ್ತು ABI), ಗುರುವಿನಂತಹ ಆರಾಮದಾಯಕ ಸಿಮ್ಯುಲೇಟರ್ ಮತ್ತು ಹೆಚ್ಚುತ್ತಿರುವ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ (ಋಣಾತ್ಮಕ, ಅಂಶಗಳು, ದೊಡ್ಡಕ್ಷರ, ಲೂಪ್‌ಗಳು, ಫ್ಯಾಕ್ಟೋರಿಯಲ್, ಫಿಬೊನಾಚಿ ಮತ್ತು ಹನೋಯ್), RISC-V ಅಸೆಂಬ್ಲರ್ ಗೋಡೆಯಾಗುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ ಮತ್ತು CPU ಹೇಗೆ ಯೋಚಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ರಸಭರಿತವಾದ ಭೂಪ್ರದೇಶವಾಗುತ್ತದೆ. ಮತ್ತು ನೀವು VHDL ಗೆ ಇಳಿಯಲು ಧೈರ್ಯ ಮಾಡಿದರೆ, ALU, ಮೆಮೊರಿ ಮತ್ತು ನಿಯಂತ್ರಣ ಹೇಗೆ ಒಟ್ಟಿಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ ಎಂಬುದನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ.: ಸೂಚನೆಗಳನ್ನು ತರುವುದು ಮತ್ತು ಲೇಜಿ ಲೋಡಿಂಗ್ ಮಾಡುವುದರಿಂದ ಹಿಡಿದು ಮೆಮೊರಿ ಇಂಟರ್ಫೇಸ್‌ಗಳು ಮತ್ತು ROM, RAM ಮತ್ತು GPIO ಹೊಂದಿರುವ ನಕ್ಷೆಯವರೆಗೆ, ಅದು ನಿಮ್ಮ ಸ್ವಂತ ಪ್ರೊಸೆಸರ್‌ನೊಂದಿಗೆ LED ಅನ್ನು ಮಿಟುಕಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.