In this question, consider the following C code and its corresponding assembly codes below.switch (x) {case 1: w = y*z; break;case 2: W = y/z;case 3: w += z; break;case 5:case 6: w = z; break;default: w = 2;}00000000004005e0 :rdx, 8rcx$0x6, &rdi200614 *0x200ab0 (, &rdi, 8)rsi, raxrdx, rax2005e0:2005e3:2005e7:2005e9:2005f0:2005£3:2005£7:2005£8:2005fb:2005fd:200600:200602:200607:20060a:20060b:200610:200613:200614:200619:0x200ab80x200ac00x200ac80x200ad0movcmpjajmpqmovimulretqmov0x200ad80x200ae00x200ae8cqtoidivrsi, rax8rcxjmp 200607 mov$0x1, Seaxadd8rcx, raxretqmovsubretqmovretqWrite the results of the command (gdb) x /10xg 0x200aa0Address Data (in 8-byte chunk in hexadecimal number, put in XX for unknown)0x200aa00x200aa80x200ab0$0x1, Seaxrdx, &rax$0x2, Seax

The specific command you mentioned, "x /10xg 0x200aa0", is used in GDB to examine the memory…

this question, consider the following C code and its corresponding assembly codes below. switch (x) { case 1: w = y* z; break; case 2: W = y/z; case 3: w += z; break; case 5: case 6: w = z; break; default: w = 2; } 00000000004005e0 : rdx, 8rcx $0x6, &rdi 200614 2005e0: 2005e3: 2005e7: 2005e9: 2005£0: 2005£3: 2005£7: 2005£8: 2005fb: 2005fd: 200600: 200602: 200607: 20060a: 20060b: 200610: 200613: 200614: 200619: mov cmp 0x200ab8 0x200ac0 0x200ac8 0x200ad0 0x200ad8 0x200ae0 0x200ae8 ja jmpq *0x200ab0 (, %rdi, 8) mov imul retq mov 8rsi, rax rdx, &rax mov add retq mov sub retq mov retq &rsi, rax cqto idiv 8rcx jmp 200607 $0x1, Seax 8rcx, rax $0x1, Seax rdx, rax $0x2, Seax Write the results of the command (gdb) x /10xg 0x200aa0 Address 0x200aa0 0x200aa8 0x200ab0 Data (in 8-byte chunk in hexadecimal number, put in XX for unknown)

this question, consider the following C code and its corresponding assembly codes below. switch (x) { case 1: w = y* z; break; case 2: W = y/z; case 3: w += z; break; case 5: case 6: w = z; break; default: w = 2; } 00000000004005e0 : rdx, 8rcx $0x6, &rdi 200614 2005e0: 2005e3: 2005e7: 2005e9: 2005£0: 2005£3: 2005£7: 2005£8: 2005fb: 2005fd: 200600: 200602: 200607: 20060a: 20060b: 200610: 200613: 200614: 200619: mov cmp 0x200ab8 0x200ac0 0x200ac8 0x200ad0 0x200ad8 0x200ae0 0x200ae8 ja jmpq *0x200ab0 (, %rdi, 8) mov imul retq mov 8rsi, rax rdx, &rax mov add retq mov sub retq mov retq &rsi, rax cqto idiv 8rcx jmp 200607 $0x1, Seax 8rcx, rax $0x1, Seax rdx, rax $0x2, Seax Write the results of the command (gdb) x /10xg 0x200aa0 Address 0x200aa0 0x200aa8 0x200ab0 Data (in 8-byte chunk in hexadecimal number, put in XX for unknown)

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

Convert the following C++ program into an x86 assembly language program.Comment the start of each "code block" that performs one of the listed mathematical calculations.Comments go to the right of the actual code, all starting on the same column.Post ONLY your ASM file here to Blackboard when complete. // Global variableschar a = 5;char b = 6;char c = 7;char d = 8;char e = 2;char f = 3;char g = 1;char h = 4;// Codeint main(){ --h; c = g + h; d = e + 22 - c - b; g = -h; ++b; a = g + d - 15; b = a + 92 - b; h = d + (-f) - d; // Move a into the eax register // Move b into the ebx register // Move c into the ecx register // Move d into the edx register // Call the DumpRegs function // Move e into the eax register // Move f into the ebx register // Move g into the ecx register // Move h into the edx register // Call the DumpRegs function e = e - 6; g = 126; --a; b = 15 - e + f; c = -f; d = -h + g - a; e = a…
PLEASE DON'T USE STRUCTS Using C programming language write a program that simulates a variant of the Tiny Harvard Architecture. In this implementation memory (RAM) is split into Instruction Memory (IM) and Data Memory (DM). Your code must implement the basic instruction set architecture (ISA) of the TinyMachine Architecture: 1 -> LOAD 2->ADD 3->STORE 4 -> SUB 5 ->IN 6-> OUT 7-> END 8 -> JMP 9 -> SKIPZ Each piece of the architecture must be accurately represented in your code (Instruction Register, Program Counter, Instruction Memory (IM), MAR1, MDR-1(MAR-1 and MDR-1 are connected to the IM). Data Memory, MAR-2, MDR2 (MAR-2 and MDR-2 are connected to the DM), and Accumulator. Instruction Memory will be represented by an integer array and each instruction will use 2 elements of the array(one for OP and the other one for address) Data Memory will be represented by an integer array and each data value uses an element of the DM array. Your Program Counter will begin pointing to the first…
Basic ARM assembly please, new to the language: Write an ARM assembly subroutine which, given the values of x and y in r0 and r1, respectively, calculates the expression: x3 + 6x2y + 12xy2 + 8y3, saving the result in r2. You don’t have to check for overflow (i.e. the solution and intermediate steps are okay to be bound to 32- bits). Hint: High-school algebra will make the solution much simpler.
Debug my C code and translate the small code into assembly language. Thank you! #include <stdio.h> #include <stdlib.h> int Length = 4; int Seq[] = {17, 34, 51, 68}; int main() { int Next = 0; //Sets value for Next. int i = 1; // sets initial value for i. while (i != 4){ //condition for while loop. Next = Next + 17; //adds integer value to Next. i++; //post increment for @param i. return Next; //returns value for Next. } // your program should use this print statement printf("The next integer in the sequence: %d\n", Next); return 0; }
Using the following C code and assembly code answer the following; C: long int nothingGreater(long int num) { if (num > 240) { return 240 - num; } else { return num; } } Assembly: 0x00000000004004ed <+0>: push %rbp 0x00000000004004ee <+1>: mov %rsp,%rbp 0x00000000004004f1 <+4>: mov %rdi,-0x8(%rbp) 0x00000000004004f5 <+8>: cmpq $0xf0,-0x8(%rbp) 0x00000000004004fd <+16>: jle 0x40050a <nothingGreater+29> 0x00000000004004ff <+18>: mov $0xf0,%eax 0x0000000000400504 <+23>: sub -0x8(%rbp),%rax 0x0000000000400508 <+27>: jmp 0x40050e <nothingGreater+33> 0x000000000040050a <+29>: mov -0x8(%rbp),%rax 0x000000000040050e <+33>: pop %rbp 0x000000000040050f <+34>: retq What are the memory addresses of the three statements that implement the if statement (provide hex addresses with 0x prefix and without leading zeroes)? The first two statements that work together: The third statement that skips the else code if the if…
Convert this following C++ code below to easy68k assembly language: int sum = 0; int c =1; for (unsigned short i = 0; i <= 10; i++) { if (c == 1 ) { sum += i; c = 0; } else { c = 1; } }
1) Write a PIC 24 assembly code that implements the following C code i = 0x1234; j = 0XDCBA; k = i+j; %3! k++; 2) Write a PIC 24 assembly code that implements the following C code #define avalue 100 #define bvalue 200 uint8 i,j, y, k i = avalue Y bvalue i+Y j = j-3 = M i+Y+5 3) Write a PIC 24 assembly code that implements the following C code #define avalue 100 uint8 i,j,k i - avalue; i+1; i %3D i; %3! j-1; k = i+j; %3!
Using the following description, please replace the return line in C code; /* * addOK: determine if x+y succeeds without overflow * Examples: * addOK(0x40000000,0x20000000) = 1 * addOK(0x40000000,0x40000000) = 0 * addOK(0x55555555,0x2AAAAAAA) = 1 * addOK(0x55555555,0x2AAAAAAB) = 0 * addOK(0x80000000,0x40000000) = 1 * addOK(0x80000000,0x80000000) = 0 * Legal ops: ! ~ & ^ | + << >> * Max ops: 20 * */ int addOK(int x, int y) { return 2 } You cannot: 1. Use any control constructs such as if, do, while, for, switch, etc. 2. Define or use any macros. 3. Define any additional functions in this file. 4. Call any functions. 5. Use any other operations, such as &&, ||, -, or ?:, not listed in the the "Legal ops" list for the function. 6. Use any form of casting. 7. Use any data type other than int.
Write a RISC-V code for the following C code: #define size 1024 int main () { int reps, int step, option, i; reps=10; step=2; option=1; char a[size]; for (i=0; reps;i++) { for (j=0;j
E In the following code block(Reference:Q11), you will a set of assembly instructions with corresponding line numbers (line numbers are for informational purpose only and they are not part of the source code). 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 mov edx, 5 dec ecx jmp LABEL1 mov eax, 1 LABEL1: mul edx jmp ecx mov edx, 0678h sub edx, eax jmp DWORD PTR [edx] neg ebx add ecx, ebx mov eax, 0 For each of the conditions/scenario listed below, indicate the corresponding line number (that cause or is associated with the condition/scenario). Enter 0 (Zero) if the condition is not caused by the block of code. 1) Memory indirect jump: type your answer... type your answer... type your answer... type your answer... 2) Register indirect jump: 3) Relative short jump: type your answer... 5) Two's complement type your answer... 4) Relative near jump: 6) Unreachable code
MIPS Assembly Write a program for RISC MIPS 32bits that challenges a person to guess a number of up to 3 digits before and 3 digits after the comma, that is, a value between 000,000 and 999,999. The program user will try to guess the number with multiple attempts, where the program will indicate at each attempt if the informed number is bigger, smaller, or if the user guessed correctly. When this happens, the program ends, showing a SUCCESS message and a total count of the number of attempts taken to get it right. The program must have a SUBROUTINE as described below. SUBROUTINE:- Input Parameters: user guess, expected value- Output: message on screen (bigger, smaller, SUCCESS)- Returns: value 1 if correct, 0 if incorrect
please modify the c language program into a pep 9 assembly language #include <stdio.h> int num, answer; int divide ( int numer, int denom ) { int quotient, remain; remain = numer; quotient = 0; while ( remain >= denom ) { remain -= denom; quotient++; } // end for return quotient; } // end of divide( ) int modulus ( int n, int d ) { int quot, rem; rem = n; quot = 0; while ( rem >= d ) { rem -= d; quot++; } // end for return rem; } // end of modulus( ) int main() { printf("? "); scanf("%d", &num); answer = divide(num, 20); printf("%d / 20 = %d\n", num, answer); answer = modulus(num, 20); printf("%d mod 20 = %d\n", num, answer); answer = divide(num, 35); printf("%d / 35 = %d\n", num, answer); answer = modulus(num, 35); printf("%d mod 35 = %d\n", num, answer); return 0; } // end of main