This is a continuation from gdb part1 post -
http://naveendavisv.blogspot.com/2020/02/gdb-tips-part1.html
- Debug an executable:
gdb executable
- Attach a process to gdb:
gdb -p procID
- Debug with a core file:
gdb -c core executable
- Execute given GDB commands upon start:
gdb -ex "commands" executable
- Start gdb and pass arguments:
gdb --args executable argument1 argument2
One of the main strength of Rust programming language is that it can easily inter-operate with other programming languages.
But as we know Rust is very very strongly typed language. When you are planning Rust to use some of the C libraries , the C type representation attributes help us .
There are some difference in the type representation for C type corresponding rust type.
We can go-ahead and check what is the size of the below struct
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=7392513792a8d390ce4756a6a8a0ed15
use std::mem;
#[repr(C)]
struct FieldStruct {
first: u8,
second: u16,
third: u8
}
// The size of the first field is 1, so add 1 to the size. Size is 1.
// The alignment of the second field is 2, so add 1 to the size for padding. Size is 2.
// The size of the second field is 2, so add 2 to the size. Size is 4.
// The alignment of the third field is 1, so add 0 to the size for padding. Size is 4.
// The size of the third field is 1, so add 1 to the size. Size is 5.
// Finally, the alignment of the struct is 2 (because the largest alignment amongst its
// fields is 2), so add 1 to the size for padding. Size is 6.
assert_eq!(6, mem::size_of::<FieldStruct>());
}
But if you remove #[repr( c )] , the struct size becomes 4.
#![allow(unused)]
fn main() {
use std::mem;
struct FieldStruct {
first: u8,
second: u16,
third: u8
}
assert_eq!(6, mem::size_of::<FieldStruct>());
}
I referred the blog for Sergey Potapov for the details.
In this below program, you would see the function print_hello_from_rust defined with extern keyword and [no_mangle] attribute.
[no_mangle] makes the compiler ignores the unknown symbols and it knows this function is going to get called from other languages.
extern keyword makes the function outside of the our library.
std::ffi::CStr. Representation of a borrowed C string. This type represents a borrowed reference to a nul-terminated array of bytes. It can be constructed safely from a &[ u8 ] slice, or unsafely from a raw *const c_char
In this example we are using *const c_char , but what is c_char ?!
c_char is coming from the standard library ‘os’ module and it is Equivalent to C’s char type.C’s char type is completely unlike Rust’s char type; while Rust’s type represents a unicode scalar value, C’s char type is just an ordinary integer. This type will always be either i8 or u8, as the type is defined as being one byte long
reference : c_char
then why *const in front of it ?
*const are called Raw pointers in Rust.Sometimes, when writing certain kinds of libraries, you’ll need to get around Rust’s safety guarantees for some reason. In this case, you can use raw pointers to implement your library, while exposing a safe interface for your users. Ref: Raw pointers
use std::ffi::{CString,CStr};
use std::os::raw::{c_char,c_int};
#[repr(C)]
pub struct Point{
x: c_int,
y: c_int,
}
impl Point {
fn new(x:c_int,y:c_int) -> Point{
// println!("Creating a Point with x = {},y = {}",x,y);
Point {x: x,y: y }
}
}
#[no_mangle]
pub extern fn create_point(x:c_int,y:c_int) -> *mut Point{
Box::into_raw(Box::new(Point::new(x,y)))
}
#[no_mangle]
pub extern fn print_hello_from_rust(data: *const c_char ){
unsafe{
let c_str = CStr::from_ptr(data);
println!("hello from rust {:?}",c_str.to_str().unwrap());
}
}
You can build the rust program with cargo
cargo new whatland -- lib
cd whatland
edit the lib.rs file with above code.
also make sure that your cargo file has
[lib]
name = "whatland"
crate-type = ["staticlib","cdylib"]
cdylib helps - A dynamic system library creation. This is used when compiling a dynamic library to be loaded from another language. This output type will create *.so files on Linux, *.dylib files on macOS, and *.dll files on Windows.
cargo build --release
I am not detailing the C program compilation, but it detailed in the blogpost: https://www.greyblake.com/blog/2017-08-10-exposing-rust-library-to-c/
You would need to use,
gcc -o ./examples/hello ./examples/hello.c -Isrc -L. -l:target/release/libwhatlang.so
We can use the trick of accepting the string as a Raw pointer using *const c_char
In order to print that bytes into a valid string slice in Rust, first we need to convert that to CStr - Representation of a borrowed C string.
then we can convert that to Str ( rust string slice) using c_str.to_str().unwrap()
I believe , Its always recommended to use #[repr©] when working with C structs, enums because it makes alignment https://doc.rust-lang.org/reference/type-layout.html#the-c-representation
#[repr(C)]
pub struct Point{
x: c_int,
y: c_int,
// x:u8, -- if you are using u8, compilier throws error,
// y:u8, stating "expected `u8`, found `i32'"
}
We implemented a method new in the rust program so that we can use in the Point struct instance creation.
impl Point {
fn new(x:c_int,y:c_int) -> Point{
Point {x: x,y: y }
}
}
Next in this example we have a export function which will be called from C program to creating Point Struct. For creating any object, we need to memory. In Rust we know that we can allocate heap memory through Box::new.
But we need to return a raw pointer to the C program, which can be done through Box::into_raw which Consumes the Box, returning a wrapped raw pointer.
23 #[no_mangle]
24 pub extern fn create_point(x:c_int,y:c_int) -> *mut Point{
25
26 Box::into_raw(Box::new(Point::new(x,y)))
27 }
We need to have our C program included with struct and create function declaration.
header file whatland.h
1 void print_hello_from_rust();
2
3 typedef struct Point{
4 int x,y;
5 }Point;
6
7 Point* create_point(int x, int y);
Now we can just call it in our main function in C
11 Point* p1 = create_point(10,20);
12 printf("Point={%d},{%d}",p1 -> x,p1 -> y);
It is very important to understand the debugging tools and their different functionalities to hack the system level programs easily.
compile your C program with -g option
$cc -g helloworld.c
Open the executable in gdb
$gdb a.out
Run the program using below commands in gdb prompt using simply ‘r’.
(gdb)run or (gdb)r
Continue run from breakpoint using ‘c’
(gdb)c
1.Setting up breakpoint in a line number
$b 10
2. breakpoint setting up in an address
$b *0x7c00
(gdb) b *0x7c00
Breakpoint 1 at 0x7c00
(gdb) c
Continuing.
Thread 1 hit Breakpoint 1, 0x00007c00 in ?? ()
3.Setting up breakpoint in a function
$b main
you can switch to tui ( text gui mode) mode using ctrl+x 2
to view the source file in the same screen.
you can ctrl+x 1 to see registers values
ctrl+x n to come back to gdb prompt.
$si \ steps through instruction
$s \ source level step through next line
$n
$next
$p foo//print the value of foo
$p car // print the value of car variable
$p/x addr //printing hexa decimal values
Current function stack frame details can be displayed using the command ‘f’ or ‘frame’
$f
$frame
The registers details or values can be seen using the command ’ info r’
info r
How can we backtrace all call stacks in gdb?!. This would be very useful command especially when you are debugging big projects source codes.
$bt
shows the backtrace of all call stacks so far.
You can switch to different frames using below command
$f 1
to switch to the first frame
f 5 switch to 5th frame etc
$info locals
shows the local variable in a function
$info args
shows arguments of the function
(gdb) help
List of classes of commands:
aliases – Aliases of other commands
breakpoints – Making program stop at certain points
data – Examining data
files – Specifying and examining files
internals – Maintenance commands
obscure – Obscure features
running – Running the program
(gdb)h breakpoints //provide help on breakpoints
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdint.h>
int main(){
int a = 1;
printf("%d",a);
//string function to put a space in the screen
puts(" ");
printf("First C program compiled to browser. a=%d",a);
return 1;
}
| Type | format | description |
|---|---|---|
| int | a = 10 | signed integer |
| long | 356L | Long integers |
| float | a = 12.34 | floating point values |
| complex | a = 3.14J | (J) Contains integer in the range 0 to 255 |
>a = 10;
>a = "naveen" //allowed
>a = a + 1 // not allowed
>a = 11 //allowed
>a = a +1 // now this is allowed
| Length | signed | unsigned |
|---|---|---|
| 8bit | i8 | u8 |
| 16bit | i16 | u16 |
| 32bit | i32 | u32 |
| 64bit | i64 | u64 |
| 128 bit | i128 | u128 |
| arch | isize | usize |
f32 and f64, which are 32 bits and 64 bits in size, respectively.fn main(){
let a:i8 = 127;
let b:i8= 129; //this will cause overflow.
let c:f32=123.32;
let d:i8 = -127;
let e:u8 = 127;
println!("{}.{},{},{},{}",a,d,c,e,b);
}
when you compile the program,
error: literal out of range for `i8`
--> datatype.rs:3:13
|
3 | let b:i8= 129;
| ^^^
|
= note: #[deny(overflowing_literals)] on by default
name1 = 'naveen'
name2 = "davis"
fullname = """naveen davis
vallooran"""
nam1[0] prints the character 'n'
I have seen in different forums that people ask following questions " Why should I learn multiple programming language ?" or “Should I learn C or Python or JavaScript ?”.
My opinion would be , you can concentrate on one language and learn it deep. But as a developer some point of time it is important that to learn multiple programming languages and understand the difference and know where these languages are strong. This would helps you take decision on which language to use for your application.
Python Hello world : you can run this program from a python interpreter or save the program in in file and run with python.
install python - python
//python programming
print("hello world")
Rust Hello world
The below Rust program needs to be saved in filename.rs and compiled with Rust compiler.t
Please follow the link for Rust installation How to install rust
///Rust programming
fn main(){
println!("hello world");
}
or You can create a rust programs using Cargo.
The link will help you to install cargo - Cargo
C Hello world
You preferred to have GCC compiler to generate C program executable.
installation -
Ubuntu GCC installation
Windows GCC
The program can be saved in a helloworld.c and compile and execute as below .
#include<stdio.h>
int main(){
printf("hello world\n");
}
| Python | Rust | C |
|---|---|---|
| Interpreting language | compiled language | compiled language |
| platform independent | cross platform individual building or compilation for each platform that it supports, |
platform dependent |
| Strongly typed dynamically typed |
strongly typed and dynamically typed | weekly typed and statically typed |
| objected oriented | Object-Oriented Programming is a way of modeling programs that originated with Simula in the 1960s and became popular with C++ in the 1990s. There are many competing definitions for what counts as OOP, and under some definitions, Rust is object-oriented; under other definitions, it is not. | structural language |
| inbuilt garbage collector | no separate garbage collector,but memory management is done automatically in compile time | manual memory management |