file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/357161.c | /*P10.9 Nesting of strcat() and strcpy() functions */
#include<stdio.h>
#include<string.h>
int main(void)
{
char str1[30] = "Subhash ";
char str2[10] = "Chandra ";
char str3[20];
strcat(strcat(str1, str2),"Bose");
printf("str1 - %s\n",str1);
strcat(strcpy(str3,"Dev"), "anshi");
printf("str3 - %s\n",str3);
return 0;
}
|
the_stack_data/7949539.c |
int glob;
void setglob(void) { glob = 8; }
void (*funcarray[10])(void) = {setglob};
void call(void (**funcarray)(void), int idx) { funcarray[idx](); }
int main(void) {
call(funcarray, 0);
test_assert(glob == 8);
return 0;
}
|
the_stack_data/159516179.c | void scilab_rt_eomday_i2i2_i2(int sin00, int sin01, int year[sin00][sin01], int sin10, int sin11, int month[sin10][sin11], int sout00, int sout01, int last_day[sout00][sout01]){
int common_year[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
int leap_year[12] = {31,29,31,30,31,30,31,31,30,31,30,31};
int i,j;
for (i = 0 ; i < sin00 ; ++i){
for (j = 0 ; j < sin01 ; ++j){
last_day[i][j] = leap_year[month[i][j]] + common_year[month[i][j]] + year[i][j];
}
}
}
|
the_stack_data/10694.c | #include<stdio.h>
int main(){
typedef struct{
char id[10];
char name[50];
float salary;
float bonus;
int age;
}employee;
employee emp1;
printf("Enter id =");
scanf("%s",emp1.id);
printf("Enter name =");
scanf("%s",emp1.name);
printf("Enter salary =");
scanf("%f",&emp1.salary);
printf("Enter bonus =");
scanf("%f",&emp1.bonus);
printf("Enter age =");
scanf("%d",&emp1.age);
printf("ID = %s\n",emp1.id);
printf("Name = %s\n",emp1.name);
printf("Salary = %.2f\n",emp1.salary);
printf("Bonus = %.2f\n",emp1.bonus);
printf("Age = %d\n",emp1.age);
system("pause");
return 0;
}
|
the_stack_data/118325.c | /* Copyright 2019 IBM Corp.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <errno.h>
#define CRONUS_PORT 8192
static bool set_nonblocking(int fd)
{
int val;
val = fcntl(fd, F_GETFL, 0);
if (val == -1) {
perror("fcntl(F_GETFL)");
return false;
}
val |= O_NONBLOCK;
val = fcntl(fd, F_SETFL, val);
if (val == -1) {
perror("fcntl(F_SETFL)");
return false;
}
return true;
}
static int listen_socket(unsigned short port)
{
struct sockaddr_in addr;
int fd, ret;
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1)
goto fail;
if (!set_nonblocking(fd))
goto fail;
addr = (struct sockaddr_in) {
.sin_family = AF_INET,
.sin_port = htons(port),
.sin_addr.s_addr = htonl(INADDR_ANY),
};
ret = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
if (ret != 0) {
perror("bind");
goto fail;
}
ret = listen(fd, 1);
if (ret != 0) {
perror("listen");
goto fail;
}
return fd;
fail:
if (fd != -1)
close(fd);
return -1;
}
static int connect_socket(struct sockaddr_in *addr)
{
int fd, ret;
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1)
goto fail;
ret = connect(fd, (struct sockaddr *)addr, sizeof(*addr));
if (ret == -1) {
perror("connect");
goto fail;
}
if (!set_nonblocking(fd))
goto fail;
return fd;
fail:
if (fd != -1)
close(fd);
return -1;
}
static int copy_data(int src_fd, int dst_fd, const char *prefix)
{
uint8_t data[1024];
ssize_t n1, n2;
unsigned int i;
n1 = read(src_fd, data, 1024);
if (n1 <= 0)
return -1;
fprintf(stderr, "read data fd=%d, len=%zi\n", src_fd, n1);
for (i=0; i<n1; i++) {
if (i % 16 == 0)
fprintf(stderr, "%s: 0x%08x", prefix, i);
fprintf(stderr, " %02x", data[i]);
if ((i+1) % 16 == 0)
fprintf(stderr, "\n");
}
fprintf(stderr, "\n");
n2 = write(dst_fd, data, n1);
if (n2 <= 0 || n1 != n2)
return -1;
return 0;
}
static int event_loop(int listen_fd, struct sockaddr_in *cro_addr)
{
struct epoll_event ev;
int client_fd = -1, proxy_fd = -1;
int epollfd, ret;
epollfd = epoll_create1(0);
if (epollfd == -1) {
perror("epollfd");
goto fail;
}
ev.events = EPOLLIN;
ev.data.fd = listen_fd;
ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_fd, &ev);
if (ret == -1) {
perror("epoll_ctl(ADD, listen_fd)");
goto fail;
}
while (1) {
struct epoll_event event;
int nfds, fd;
nfds = epoll_wait(epollfd, &event, 1, -1);
if (nfds == -1) {
perror("epoll_wait");
goto fail;
}
if (event.data.fd == listen_fd) {
struct sockaddr_in addr;
socklen_t addrlen = sizeof(addr);
fd = accept(listen_fd, (struct sockaddr *)&addr, &addrlen);
if (fd == -1) {
perror("accept");
continue;
}
if (client_fd != -1) {
fprintf(stderr, "Dropping connection\n");
close(fd);
continue;
}
proxy_fd = connect_socket(cro_addr);
if (proxy_fd == -1) {
close(fd);
continue;
}
if (!set_nonblocking(fd)) {
close(proxy_fd);
close(fd);
continue;
}
fprintf(stderr, "accepted connection fd=%d\n", fd);
client_fd = fd;
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = client_fd;
ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, client_fd, &ev);
if (ret == -1) {
perror("epoll_ctl(ADD, client_fd)");
close(client_fd);
client_fd = -1;
close(proxy_fd);
proxy_fd = -1;
continue;
}
fprintf(stderr, "added fd=%d\n", client_fd);
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = proxy_fd;
ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, proxy_fd, &ev);
if (ret == -1) {
perror("epoll_ctl(ADD, proxy_fd)");
close(client_fd);
client_fd = -1;
close(proxy_fd);
proxy_fd = -1;
}
continue;
}
ret = 0;
if (event.data.fd == client_fd) {
ret = copy_data(client_fd, proxy_fd, "REQUEST");
} else if (event.data.fd == proxy_fd) {
ret = copy_data(proxy_fd, client_fd, "REPLY");
}
if (ret != 0) {
fprintf(stderr, "closed fd=%d\n", client_fd);
epoll_ctl(epollfd, EPOLL_CTL_DEL, client_fd, NULL);
close(client_fd);
client_fd = -1;
epoll_ctl(epollfd, EPOLL_CTL_DEL, proxy_fd, NULL);
close(proxy_fd);
proxy_fd = -1;
}
}
fail:
if (epollfd != -1) {
if (client_fd != -1) {
epoll_ctl(epollfd, EPOLL_CTL_DEL, client_fd, NULL);
close(client_fd);
}
if (proxy_fd != -1) {
epoll_ctl(epollfd, EPOLL_CTL_DEL, proxy_fd, NULL);
close(proxy_fd);
}
epoll_ctl(epollfd, EPOLL_CTL_DEL, listen_fd, NULL);
close(listen_fd);
}
return -1;
}
int main(int argc, const char **argv)
{
struct addrinfo hints, *result;
struct sockaddr_in addr;
const char *hostname;
unsigned short port = CRONUS_PORT;
int listen_fd, ret;
if (argc < 2 || argc > 3) {
fprintf(stderr, "Usage: %s <croserver-ip> [<croserver-port>]\n", argv[0]);
exit(1);
}
hostname = argv[1];
if (argc == 3) {
port = atoi(argv[2]);
}
hints = (struct addrinfo) {
.ai_family = AF_INET,
};
ret = getaddrinfo(hostname, NULL, &hints, &result);
if (ret != 0) {
perror("getaddrinfo");
exit(1);
}
addr = *(struct sockaddr_in *)result->ai_addr;
addr.sin_port = htons(port);
freeaddrinfo(result);
listen_fd = listen_socket(CRONUS_PORT);
if (listen_fd == -1)
exit(1);
return event_loop(listen_fd, &addr);
}
|
the_stack_data/98990.c | //file: _insn_test_v2cmpleu_X0.c
//op=286
#include <stdio.h>
#include <stdlib.h>
void func_exit(void) {
printf("%s\n", __func__);
exit(0);
}
void func_call(void) {
printf("%s\n", __func__);
exit(0);
}
unsigned long mem[2] = { 0x3ef8a65156ec00ac, 0x59fad680489ec628 };
int main(void) {
unsigned long a[4] = { 0, 0 };
asm __volatile__ (
"moveli r50, 27539\n"
"shl16insli r50, r50, -29737\n"
"shl16insli r50, r50, 27831\n"
"shl16insli r50, r50, -25163\n"
"moveli r13, 694\n"
"shl16insli r13, r13, -3893\n"
"shl16insli r13, r13, 5047\n"
"shl16insli r13, r13, -7475\n"
"moveli r2, -31766\n"
"shl16insli r2, r2, 20217\n"
"shl16insli r2, r2, -13682\n"
"shl16insli r2, r2, -10053\n"
"{ v2cmpleu r50, r13, r2 ; fnop }\n"
"move %0, r50\n"
"move %1, r13\n"
"move %2, r2\n"
:"=r"(a[0]),"=r"(a[1]),"=r"(a[2]));
printf("%016lx\n", a[0]);
printf("%016lx\n", a[1]);
printf("%016lx\n", a[2]);
return 0;
}
|
the_stack_data/140765058.c | /*
* Q. Write code to reverse a C-style string
* [Prav] Er, guess will have to write this one in C
*/
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[]) {
if(argc != 2) {
printf("Usage: %s string", argv[0]);
return 1;
}
int len = strlen(argv[1]);
for(int i=0; i < len / 2; i++) {
char t = argv[1][i];
argv[1][i] = argv[1][len - i - 1];
argv[1][len - i - 1] = t;
}
printf("Reversed string: %s\n", argv[1]);
return 0;
} |
the_stack_data/922742.c | /**************************************************************************/
/*!
@file board_pca10056.c
@author hathach
@section LICENSE
Software License Agreement (BSD License)
Copyright (c) 2018, hathach (tinyusb.org)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holders nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
This file is part of the tinyusb stack.
*/
/**************************************************************************/
#ifdef BOARD_PCA10056
#include "bsp/board.h"
#include "nrfx/hal/nrf_gpio.h"
#include "nrfx/drivers/include/nrfx_power.h"
#include "nrfx/drivers/include/nrfx_qspi.h"
#include "tusb.h"
/*------------------------------------------------------------------*/
/* MACRO TYPEDEF CONSTANT ENUM
*------------------------------------------------------------------*/
#define LED_PIN 13
#define LED_STATE_ON 0
uint8_t _button_pins[] = { 11, 12, 24, 25 };
#define BOARD_BUTTON_COUNT sizeof(_button_pins)
/*------------------------------------------------------------------*/
/* TUSB HAL MILLISECOND
*------------------------------------------------------------------*/
#if CFG_TUSB_OS == OPT_OS_NONE
volatile uint32_t system_ticks = 0;
void SysTick_Handler (void)
{
system_ticks++;
}
uint32_t tusb_hal_millis(void)
{
return board_tick2ms(system_ticks);
}
#endif
/*------------------------------------------------------------------*/
/* BOARD API
*------------------------------------------------------------------*/
enum {
QSPI_CMD_RSTEN = 0x66,
QSPI_CMD_RST = 0x99,
QSPI_CMD_WRSR = 0x01,
QSPI_CMD_READID = 0x90
};
/* tinyusb function that handles power event (detected, ready, removed)
* We must call it within SD's SOC event handler, or set it as power event handler if SD is not enabled.
*/
extern void tusb_hal_nrf_power_event(uint32_t event);
void board_init(void)
{
// Config clock source: XTAL or RC in sdk_config.h
NRF_CLOCK->LFCLKSRC = (uint32_t)((CLOCK_LFCLKSRC_SRC_Xtal << CLOCK_LFCLKSRC_SRC_Pos) & CLOCK_LFCLKSRC_SRC_Msk);
NRF_CLOCK->TASKS_LFCLKSTART = 1UL;
// LEDs
nrf_gpio_cfg_output(LED_PIN);
board_led_control(false);
// Button
for(uint8_t i=0; i<BOARD_BUTTON_COUNT; i++) nrf_gpio_cfg_input(_button_pins[i], NRF_GPIO_PIN_PULLUP);
#if CFG_TUSB_OS == OPT_OS_NONE
// Tick init
SysTick_Config(SystemCoreClock/1000);
#endif
// 64 Mbit qspi flash
#ifdef BOARD_MSC_FLASH_QSPI
nrfx_qspi_config_t qspi_cfg = {
.xip_offset = 0,
.pins = {
.sck_pin = 19,
.csn_pin = 17,
.io0_pin = 20,
.io1_pin = 21,
.io2_pin = 22,
.io3_pin = 23,
},
.prot_if = {
.readoc = NRF_QSPI_READOC_READ4IO,
.writeoc = NRF_QSPI_WRITEOC_PP4IO,
.addrmode = NRF_QSPI_ADDRMODE_24BIT,
.dpmconfig = false, // deep power down
},
.phy_if = {
.sck_freq = NRF_QSPI_FREQ_32MDIV1,
.sck_delay = 1,
.spi_mode = NRF_QSPI_MODE_0,
.dpmen = false
},
.irq_priority = 7,
};
// NULL callback for blocking API
nrfx_qspi_init(&qspi_cfg, NULL, NULL);
nrf_qspi_cinstr_conf_t cinstr_cfg = {
.opcode = 0,
.length = 0,
.io2_level = true,
.io3_level = true,
.wipwait = false,
.wren = false
};
// Send reset enable
cinstr_cfg.opcode = QSPI_CMD_RSTEN;
cinstr_cfg.length = NRF_QSPI_CINSTR_LEN_1B;
nrfx_qspi_cinstr_xfer(&cinstr_cfg, NULL, NULL);
// Send reset command
cinstr_cfg.opcode = QSPI_CMD_RST;
cinstr_cfg.length = NRF_QSPI_CINSTR_LEN_1B;
nrfx_qspi_cinstr_xfer(&cinstr_cfg, NULL, NULL);
NRFX_DELAY_US(100); // wait for flash reset
// Send (Read ID + 3 dummy bytes) + Receive 2 bytes of Manufacture + Device ID
uint8_t dummy[6] = { 0 };
uint8_t id_resp[6] = { 0 };
cinstr_cfg.opcode = QSPI_CMD_READID;
cinstr_cfg.length = 6;
// Bug with -nrf_qspi_cinstrdata_get() didn't combine data.
// https://devzone.nordicsemi.com/f/nordic-q-a/38540/bug-nrf_qspi_cinstrdata_get-didn-t-collect-data-from-both-cinstrdat1-and-cinstrdat0
nrfx_qspi_cinstr_xfer(&cinstr_cfg, dummy, id_resp);
// Due to the bug, we collect data manually
uint8_t dev_id = (uint8_t) NRF_QSPI->CINSTRDAT1;
uint8_t mfgr_id = (uint8_t) ( NRF_QSPI->CINSTRDAT0 >> 24 );
// Switch to quad mode
uint16_t sr_quad_en = 0x40;
cinstr_cfg.opcode = QSPI_CMD_WRSR;
cinstr_cfg.length = 3;
cinstr_cfg.wipwait = cinstr_cfg.wren = true;
nrfx_qspi_cinstr_xfer(&cinstr_cfg, &sr_quad_en, NULL);
#endif
// USB power may already be ready at this time -> no event generated
// We need to invoke the handler based on the status initially
uint32_t usb_reg;
#ifdef SOFTDEVICE_PRESENT
uint8_t sd_en = false;
(void) sd_softdevice_is_enabled(&sd_en);
if ( sd_en ) {
sd_power_usbdetected_enable(true);
sd_power_usbpwrrdy_enable(true);
sd_power_usbremoved_enable(true);
sd_power_usbregstatus_get(&usb_reg);
}else
#else
{
// Power module init
const nrfx_power_config_t pwr_cfg = { 0 };
nrfx_power_init(&pwr_cfg);
// Register tusb function as USB power handler
const nrfx_power_usbevt_config_t config = { .handler = (nrfx_power_usb_event_handler_t) tusb_hal_nrf_power_event };
nrfx_power_usbevt_init(&config);
nrfx_power_usbevt_enable();
usb_reg = NRF_POWER->USBREGSTATUS;
}
#endif
if ( usb_reg & POWER_USBREGSTATUS_VBUSDETECT_Msk ) {
tusb_hal_nrf_power_event(NRFX_POWER_USB_EVT_DETECTED);
}
if ( usb_reg & POWER_USBREGSTATUS_OUTPUTRDY_Msk ) {
tusb_hal_nrf_power_event(NRFX_POWER_USB_EVT_READY);
}
}
void board_led_control(bool state)
{
nrf_gpio_pin_write(LED_PIN, state ? LED_STATE_ON : (1-LED_STATE_ON));
}
uint32_t board_buttons(void)
{
uint32_t ret = 0;
for(uint8_t i=0; i<BOARD_BUTTON_COUNT; i++)
{
// button is active LOW
ret |= ( nrf_gpio_pin_read(_button_pins[i]) ? 0 : (1 << i));
}
return ret;
}
uint8_t board_uart_getchar(void)
{
return 0;
}
void board_uart_putchar(uint8_t c)
{
(void) c;
}
#endif
|
the_stack_data/97013117.c | #include <stdio.h>
void pivo(int a);
int main(void){
int a;
scanf("%d",&a);
pivo(a);
return 0;
}
void pivo(int a){
int f = 0,s = 1,i,result = 0;
if (a==0){
printf("0\n");
}else if (a==1){
printf("1\n");
}else{
for (int i = 0 ; i < a-1 ; ++i){
result = s + f;
f = s;
s = result;
}
printf("%d\n",result);
}
} |
the_stack_data/1056503.c |
/* text version of maze 'mazefiles/binary/apec2010.maz'
generated by mazetool (c) Peter Harrison 2018
o---o---o---o---o---o---o---o---o---o---o---o---o---o---o---o---o
| |
o o---o---o---o---o---o---o---o---o---o---o---o---o---o o---o
| | | | | |
o o o---o o o---o o---o o o---o o---o---o o o
| | | | | | | | | | |
o o---o o o o---o o o o---o o---o o---o---o---o
| | | | | | | | | | |
o o o---o o---o o---o o o---o o---o---o---o o o
| | | | | | | | |
o o o---o---o---o---o o---o---o o---o o o o o o
| | | | | | | | |
o o---o---o o o o---o---o---o---o---o o---o---o---o o
| | | | | | | | | |
o o o o---o---o o o---o---o o o---o o---o o o
| | | | | | | | | | | |
o o o o---o o o o o o o o o---o o---o o
| | | | | | | | | | | |
o o o o o---o---o o o---o o o o o o---o o
| | | | | | | | | | | |
o o o---o---o o o o---o---o o---o---o o---o o o
| | | | | | | | | |
o o o o o o---o---o o o---o---o o---o---o o o
| | | | | | | | | |
o o o o o o---o o---o---o---o---o o---o o o o
| | | | | | | | | | | | |
o o---o---o---o---o---o o o---o o o---o o o o o
| | | | | | |
o o o o---o---o---o---o---o o---o o o o o o o
| | | | | | | | |
o o o---o---o---o---o---o---o---o---o---o---o---o---o---o o
| | |
o---o---o---o---o---o---o---o---o---o---o---o---o---o---o---o---o
*/
int apec2010_maz[] ={
0x0E, 0x0A, 0x08, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x09,
0x0C, 0x0A, 0x03, 0x0C, 0x0A, 0x0A, 0x0A, 0x0A, 0x08, 0x0B, 0x0C, 0x0A, 0x09, 0x0C, 0x09, 0x05,
0x05, 0x0C, 0x09, 0x06, 0x0A, 0x09, 0x0C, 0x0A, 0x00, 0x0B, 0x05, 0x0D, 0x06, 0x03, 0x05, 0x05,
0x05, 0x05, 0x05, 0x0E, 0x08, 0x03, 0x06, 0x09, 0x07, 0x0C, 0x03, 0x04, 0x0A, 0x0A, 0x03, 0x05,
0x05, 0x05, 0x05, 0x0E, 0x00, 0x0A, 0x09, 0x04, 0x0B, 0x06, 0x09, 0x05, 0x0C, 0x0A, 0x09, 0x05,
0x05, 0x05, 0x05, 0x0D, 0x07, 0x0C, 0x03, 0x06, 0x0A, 0x0A, 0x03, 0x06, 0x03, 0x0D, 0x05, 0x05,
0x05, 0x05, 0x06, 0x02, 0x09, 0x06, 0x08, 0x0A, 0x0A, 0x09, 0x0C, 0x09, 0x0E, 0x00, 0x03, 0x05,
0x05, 0x05, 0x0C, 0x09, 0x06, 0x09, 0x04, 0x08, 0x09, 0x05, 0x05, 0x06, 0x0A, 0x03, 0x0D, 0x05,
0x05, 0x04, 0x03, 0x05, 0x0C, 0x03, 0x07, 0x06, 0x03, 0x05, 0x05, 0x0C, 0x0A, 0x0A, 0x01, 0x05,
0x05, 0x07, 0x0C, 0x03, 0x05, 0x0C, 0x0A, 0x0A, 0x0A, 0x03, 0x04, 0x03, 0x0D, 0x0C, 0x03, 0x05,
0x05, 0x0E, 0x00, 0x0B, 0x05, 0x05, 0x0C, 0x0A, 0x0A, 0x09, 0x07, 0x0E, 0x00, 0x03, 0x0D, 0x05,
0x05, 0x0C, 0x03, 0x0E, 0x00, 0x03, 0x06, 0x0A, 0x09, 0x06, 0x0A, 0x09, 0x05, 0x0C, 0x01, 0x05,
0x05, 0x06, 0x08, 0x0B, 0x07, 0x0C, 0x0A, 0x09, 0x06, 0x09, 0x0C, 0x03, 0x06, 0x01, 0x05, 0x05,
0x05, 0x0E, 0x00, 0x0A, 0x0B, 0x05, 0x0E, 0x00, 0x09, 0x05, 0x06, 0x09, 0x0D, 0x07, 0x05, 0x05,
0x05, 0x0E, 0x02, 0x0A, 0x0A, 0x02, 0x0B, 0x07, 0x06, 0x03, 0x0E, 0x00, 0x03, 0x0E, 0x00, 0x01,
0x06, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x02, 0x0B, 0x0E, 0x03, 0x07,
};
/* end of mazefile */
|
the_stack_data/1178230.c | /**
* Compiler implementation of the
* $(LINK2 http://www.dlang.org, D programming language).
*
* Copyright: Copyright (C) 1995-1998 by Symantec
* Copyright (C) 2000-2018 by The D Language Foundation, All Rights Reserved
* Authors: $(LINK2 http://www.digitalmars.com, Walter Bright)
* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/backend/cgsched.c, backend/cgsched.c)
*/
#if (SCPP && !HTOD) || MARS
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "cc.h"
#include "el.h"
#include "code.h"
#include "oper.h"
#include "global.h"
#include "type.h"
#include "exh.h"
#include "list.h"
static char __file__[] = __FILE__; /* for tassert.h */
#include "tassert.h"
// If we use Pentium Pro scheduler
#if 0
#define PRO (config.target_scheduler >= TARGET_PentiumPro)
#else
#define PRO (config.target_cpu >= TARGET_PentiumPro)
#endif
enum
{
FPfstp = 1, /// FSTP mem
FPfld = 2, /// FLD mem
FPfop = 3, /// Fop ST0,mem or Fop ST0
};
enum
{
CIFLarraybounds = 1, /// this instruction is a jmp to array bounds
CIFLea = 2, /// this instruction has a memory-referencing
/// modregrm EA byte
CIFLnostage = 4, /// don't stage these instructions
CIFLpush = 8, /// it's a push we can swap around
};
// Struct where we gather information about an instruction
struct Cinfo
{
code *c; // the instruction
unsigned char pair; // pairing information
unsigned char sz; // operand size
unsigned char isz; // instruction size
// For floating point scheduling
unsigned char fxch_pre;
unsigned char fxch_post;
unsigned char fp_op; /// FPxxxx
unsigned char flags; /// CIFLxxx
unsigned r; // read mask
unsigned w; // write mask
unsigned a; // registers used in addressing mode
unsigned char reg; // reg field of modregrm byte
unsigned char uops; // Pentium Pro micro-ops
unsigned sibmodrm; // (sib << 8) + mod__rm byte
unsigned spadjust; // if !=0, then amount ESP changes as a result of this
// instruction being executed
int fpuadjust; // if !=0, then amount FPU stack changes as a result
// of this instruction being executed
void print(); // pretty-printer
};
code *simpleops(code *c,regm_t scratch);
static code *schedule(code *c,regm_t scratch);
code *peephole(code *c,regm_t scratch);
/*****************************************
* Do Pentium optimizations.
* Input:
* scratch scratch registers we can use
*/
static void cgsched_pentium(code **pc,regm_t scratch)
{
//printf("scratch = x%02x\n",scratch);
if (config.target_scheduler >= TARGET_80486)
{
if (!I64)
*pc = peephole(*pc,0);
if (I32) // forget about 16 bit code
{
if (config.target_cpu == TARGET_Pentium ||
config.target_cpu == TARGET_PentiumMMX)
*pc = simpleops(*pc,scratch);
*pc = schedule(*pc,0);
}
}
}
/************************************
* Entry point
*/
void cgsched_block(block* b)
{
if (config.flags4 & CFG4speed &&
config.target_cpu >= TARGET_Pentium &&
b->BC != BCasm)
{
regm_t scratch = allregs;
scratch &= ~(b->Bregcon.used | b->Bregcon.params | mfuncreg);
scratch &= ~(b->Bregcon.immed.mval | b->Bregcon.cse.mval);
cgsched_pentium(&b->Bcode,scratch);
//printf("after schedule:\n"); WRcodlst(b->Bcode);
}
}
enum
{
NP = 0, /// not pairable
PU = 1, /// pairable in U only, never executed in V
PV = 2, /// pairable in V only
UV = (PU|PV), /// pairable in both U and V
PE = 4, /// register contention exception
PF = 8, /// flags contention exception
FX = 0x10, /// pairable with FXCH instruction
};
static unsigned char pentcycl[256] =
{
UV,UV,UV,UV, UV,UV,NP,NP, // 0
UV,UV,UV,UV, UV,UV,NP,NP, // 8
PU,PU,PU,PU, PU,PU,NP,NP, // 10
PU,PU,PU,PU, PU,PU,NP,NP, // 18
UV,UV,UV,UV, UV,UV,NP,NP, // 20
UV,UV,UV,UV, UV,UV,NP,NP, // 28
UV,UV,UV,UV, UV,UV,NP,NP, // 30
UV,UV,UV,UV, UV,UV,NP,NP, // 38
UV,UV,UV,UV, UV,UV,UV,UV, // 40
UV,UV,UV,UV, UV,UV,UV,UV, // 48
PE|UV,PE|UV,PE|UV,PE|UV, PE|UV,PE|UV,PE|UV,PE|UV, // 50 PUSH reg
PE|UV,PE|UV,PE|UV,PE|UV, PE|UV,PE|UV,PE|UV,PE|UV, // 58 POP reg
NP,NP,NP,NP, NP,NP,NP,NP, // 60
PE|UV,NP,PE|UV,NP, NP,NP,NP,NP, // 68
PV|PF,PV|PF,PV|PF,PV|PF, PV|PF,PV|PF,PV|PF,PV|PF, // 70 Jcc rel8
PV|PF,PV|PF,PV|PF,PV|PF, PV|PF,PV|PF,PV|PF,PV|PF, // 78 Jcc rel8
NP,NP,NP,NP, NP,NP,NP,NP, // 80
UV,UV,UV,UV, NP,UV,NP,NP, // 88
NP,NP,NP,NP, NP,NP,NP,NP, // 90
NP,NP,NP,NP, NP,NP,NP,NP, // 98
UV,UV,UV,UV, NP,NP,NP,NP, // A0
UV,UV,NP,NP, NP,NP,NP,NP, // A8
UV,UV,UV,UV, UV,UV,UV,UV, // B0
UV,UV,UV,UV, UV,UV,UV,UV, // B8
NP,NP,NP,NP, NP,NP,NP,NP, // C0
NP,NP,NP,NP, NP,NP,NP,NP, // C8
PU,PU,NP,NP, NP,NP,NP,NP, // D0
FX,NP,FX,FX, NP,NP,FX,NP, // D8 all floating point
NP,NP,NP,NP, NP,NP,NP,NP, // E0
PE|PV,PV,NP,PV, NP,NP,NP,NP, // E8
NP,NP,NP,NP, NP,NP,NP,NP, // F0
NP,NP,NP,NP, NP,NP,NP,NP, // F8
};
/********************************************
* For each opcode, determine read [0] and written [1] masks.
*/
enum
{
EA = 0x100000,
R = 0x200000, /// register (reg of modregrm field)
N = 0x400000, /// other things modified, not swappable
B = 0x800000, /// it's a byte operation
C = 0x1000000, /// floating point flags
mMEM = 0x2000000, /// memory
S = 0x4000000, /// floating point stack
F = 0x8000000, /// flags
};
static unsigned oprw[256][2] =
{
// 00
EA|R|B, F|EA|B, // ADD
EA|R, F|EA,
EA|R|B, F|R|B,
EA|R, F|R,
mAX, F|mAX,
mAX, F|mAX,
N, N, // PUSH ES
N, N, // POP ES
// 08
EA|R|B, F|EA|B, // OR
EA|R, F|EA,
EA|R|B, F|R|B,
EA|R, F|R,
mAX, F|mAX,
mAX, F|mAX,
N, N, // PUSH CS
N, N, // 2 byte escape
// 10
F|EA|R|B,F|EA|B, // ADC
F|EA|R, F|EA,
F|EA|R|B,F|R|B,
F|EA|R, F|R,
F|mAX, F|mAX,
F|mAX, F|mAX,
N, N, // PUSH SS
N, N, // POP SS
// 18
F|EA|R|B,F|EA|B, // SBB
F|EA|R, F|EA,
F|EA|R|B,F|R|B,
F|EA|R, F|R,
F|mAX, F|mAX,
F|mAX, F|mAX,
N, N, // PUSH DS
N, N, // POP DS
// 20
EA|R|B, F|EA|B, // AND
EA|R, F|EA,
EA|R|B, F|R|B,
EA|R, F|R,
mAX, F|mAX,
mAX, F|mAX,
N, N, // SEG ES
F|mAX, F|mAX, // DAA
// 28
EA|R|B, F|EA|B, // SUB
EA|R, F|EA,
EA|R|B, F|R|B,
EA|R, F|R,
mAX, F|mAX,
mAX, F|mAX,
N, N, // SEG CS
F|mAX, F|mAX, // DAS
// 30
EA|R|B, F|EA|B, // XOR
EA|R, F|EA,
EA|R|B, F|R|B,
EA|R, F|R,
mAX, F|mAX,
mAX, F|mAX,
N, N, // SEG SS
F|mAX, F|mAX, // AAA
// 38
EA|R|B, F, // CMP
EA|R, F,
EA|R|B, F,
EA|R, F,
mAX, F, // CMP AL,imm8
mAX, F, // CMP EAX,imm16/32
N, N, // SEG DS
N, N, // AAS
// 40
mAX, F|mAX, // INC EAX
mCX, F|mCX,
mDX, F|mDX,
mBX, F|mBX,
mSP, F|mSP,
mBP, F|mBP,
mSI, F|mSI,
mDI, F|mDI,
// 48
mAX, F|mAX, // DEC EAX
mCX, F|mCX,
mDX, F|mDX,
mBX, F|mBX,
mSP, F|mSP,
mBP, F|mBP,
mSI, F|mSI,
mDI, F|mDI,
// 50
mAX|mSP, mSP|mMEM, // PUSH EAX
mCX|mSP, mSP|mMEM,
mDX|mSP, mSP|mMEM,
mBX|mSP, mSP|mMEM,
mSP|mSP, mSP|mMEM,
mBP|mSP, mSP|mMEM,
mSI|mSP, mSP|mMEM,
mDI|mSP, mSP|mMEM,
// 58
mSP|mMEM, mAX|mSP, // POP EAX
mSP|mMEM, mCX|mSP,
mSP|mMEM, mDX|mSP,
mSP|mMEM, mBX|mSP,
mSP|mMEM, mSP|mSP,
mSP|mMEM, mBP|mSP,
mSP|mMEM, mSI|mSP,
mSP|mMEM, mDI|mSP,
// 60
N, N, // PUSHA
N, N, // POPA
N, N, // BOUND Gv,Ma
N, N, // ARPL Ew,Rw
N, N, // SEG FS
N, N, // SEG GS
N, N, // operand size prefix
N, N, // address size prefix
// 68
mSP, mSP|mMEM, // PUSH immed16/32
EA, F|R, // IMUL Gv,Ev,lv
mSP, mSP|mMEM, // PUSH immed8
EA, F|R, // IMUL Gv,Ev,lb
N, N, // INSB Yb,DX
N, N, // INSW/D Yv,DX
N, N, // OUTSB DX,Xb
N, N, // OUTSW/D DX,Xv
// 70
F|N, N,
F|N, N,
F|N, N,
F|N, N,
F|N, N,
F|N, N,
F|N, N,
F|N, N,
// 78
F|N, N,
F|N, N,
F|N, N,
F|N, N,
F|N, N,
F|N, N,
F|N, N,
F|N, N,
// 80
N, N,
N, N,
N, N,
N, N,
EA|R, F, // TEST EA,r8
EA|R, F, // TEST EA,r16/32
EA|R, EA|R, // XCHG EA,r8
EA|R, EA|R, // XCHG EA,r16/32
// 88
R|B, EA|B, // MOV EA8,r8
R, EA, // MOV EA,r16/32
EA|B, R|B, // MOV r8,EA8
EA, R, // MOV r16/32,EA
N, N, // MOV EA,segreg
EA, R, // LEA r16/32,EA
N, N, // MOV segreg,EA
mSP|mMEM, EA|mSP, // POP mem16/32
// 90
0, 0, // NOP
mAX|mCX, mAX|mCX,
mAX|mDX, mAX|mDX,
mAX|mBX, mAX|mBX,
mAX|mSP, mAX|mSP,
mAX|mBP, mAX|mBP,
mAX|mSI, mAX|mSI,
mAX|mDI, mAX|mDI,
// 98
mAX, mAX, // CBW
mAX, mDX, // CWD
N, N|F, // CALL far ptr
N, N, // WAIT
F|mSP, mSP|mMEM, // PUSHF
mSP|mMEM, F|mSP, // POPF
mAX, F, // SAHF
F, mAX, // LAHF
// A0
mMEM, mAX, // MOV AL,moffs8
mMEM, mAX, // MOV EAX,moffs32
mAX, mMEM, // MOV moffs8,AL
mAX, mMEM, // MOV moffs32,EAX
N, N, // MOVSB
N, N, // MOVSW/D
N, N, // CMPSB
N, N, // CMPSW/D
// A8
mAX, F, // TEST AL,imm8
mAX, F, // TEST AX,imm16
N, N, // STOSB
N, N, // STOSW/D
N, N, // LODSB
N, N, // LODSW/D
N, N, // SCASB
N, N, // SCASW/D
// B0
0, mAX, // MOV AL,imm8
0, mCX,
0, mDX,
0, mBX,
0, mAX,
0, mCX,
0, mDX,
0, mBX,
// B8
0, mAX, // MOV AX,imm16
0, mCX,
0, mDX,
0, mBX,
0, mSP,
0, mBP,
0, mSI,
0, mDI,
// C0
EA, F|EA, // Shift Eb,Ib
EA, F|EA,
N, N,
N, N,
N, N,
N, N,
0, EA|B, // MOV EA8,imm8
0, EA, // MOV EA,imm16
// C8
N, N, // ENTER
N, N, // LEAVE
N, N, // RETF lw
N, N, // RETF
N, N, // INT 3
N, N, // INT lb
N, N, // INTO
N, N, // IRET
// D0
EA, F|EA, // Shift EA,1
EA, F|EA,
EA|mCX, F|EA, // Shift EA,CL
EA|mCX, F|EA,
mAX, F|mAX, // AAM
mAX, F|mAX, // AAD
N, N, // reserved
mAX|mBX|mMEM, mAX, // XLAT
// D8
N, N,
N, N,
N, N,
N, N,
N, N,
N, N,
N, N,
N, N,
// E0
F|mCX|N,mCX|N, // LOOPNE jb
F|mCX|N,mCX|N, // LOOPE jb
mCX|N, mCX|N, // LOOP jb
mCX|N, N, // JCXZ jb
N, N, // IN AL,lb
N, N, // IN EAX,lb
N, N, // OUT lb,AL
N, N, // OUT lb,EAX
// E8
N, N|F, // CALL jv
N, N, // JMP Jv
N, N, // JMP Ab
N, N, // JMP jb
N|mDX, N|mAX, // IN AL,DX
N|mDX, N|mAX, // IN AX,DX
N|mAX|mDX,N, // OUT DX,AL
N|mAX|mDX,N, // OUT DX,AX
// F0
N, N, // LOCK
N, N, // reserved
N, N, // REPNE
N, N, // REP,REPE
N, N, // HLT
F, F, // CMC
N, N,
N, N,
// F8
0, F, // CLC
0, F, // STC
N, N, // CLI
N, N, // STI
N, N, // CLD
N, N, // STD
EA, F|EA, // INC/DEC
N, N,
};
/****************************************
* Same thing, but for groups.
*/
static unsigned grprw[8][8][2] =
{
// Grp 1
EA, F|EA, // ADD
EA, F|EA, // OR
F|EA, F|EA, // ADC
F|EA, F|EA, // SBB
EA, F|EA, // AND
EA, F|EA, // SUB
EA, F|EA, // XOR
EA, F, // CMP
// Grp 3
EA, F, // TEST EA,imm
N, N, // reserved
EA, EA, // NOT
EA, F|EA, // NEG
mAX|EA, F|mAX|mDX, // MUL
mAX|EA, F|mAX|mDX, // IMUL
mAX|mDX|EA, F|mAX|mDX, // DIV
#if 0
// Could generate an exception we want to catch
mAX|mDX|EA|N, F|mAX|mDX|N, // IDIV
#else
mAX|mDX|EA, F|mAX|mDX, // IDIV
#endif
// Grp 5
EA, F|EA, // INC Ev
EA, F|EA, // DEC Ev
N|EA, N, // CALL Ev
N|EA, N, // CALL eP
N|EA, N, // JMP Ev
N|EA, N, // JMP Ep
mSP|EA, mSP|mMEM, // PUSH Ev
N, N, // reserved
// Grp 3, byte version
EA|B, F, // TEST EA,imm
N, N, // reserved
EA|B, EA|B, // NOT
EA|B, F|EA|B, // NEG
mAX|EA, F|mAX, // MUL
mAX|EA, F|mAX, // IMUL
mAX|EA, F|mAX, // DIV
#if 0
// Could generate an exception we want to catch
mAX|EA|N, F|mAX|N, // IDIV
#else
mAX|EA, F|mAX, // IDIV
#endif
};
/********************************************
* For floating point opcodes 0xD8..0xDF, with Irm < 0xC0.
* [][][0] = read
* [1] = write
*/
static unsigned grpf1[8][8][2] =
{
// 0xD8
EA|S, S|C, // FADD float
EA|S, S|C, // FMUL float
EA|S, C, // FCOM float
EA|S, S|C, // FCOMP float
EA|S, S|C, // FSUB float
EA|S, S|C, // FSUBR float
EA|S, S|C, // FDIV float
EA|S, S|C, // FDIVR float
// 0xD9
EA, S|C, // FLD float
N, N, //
S, EA|C, // FST float
S, EA|S|C, // FSTP float
N, N, // FLDENV
N, N, // FLDCW
N, N, // FSTENV
N, N, // FSTCW
// 0xDA
EA|S, S|C, // FIADD long
EA|S, S|C, // FIMUL long
EA|S, C, // FICOM long
EA|S, S|C, // FICOMP long
EA|S, S|C, // FISUB long
EA|S, S|C, // FISUBR long
EA|S, S|C, // FIDIV long
EA|S, S|C, // FIDIVR long
// 0xDB
EA, S|C, // FILD long
S, EA|S|C, // FISTTP int
S, EA|C, // FIST long
S, EA|S|C, // FISTP long
N, N, //
EA, S|C, // FLD real80
N, N, //
S, EA|S|C, // FSTP real80
// 0xDC
EA|S, S|C, // FADD double
EA|S, S|C, // FMUL double
EA|S, C, // FCOM double
EA|S, S|C, // FCOMP double
EA|S, S|C, // FSUB double
EA|S, S|C, // FSUBR double
EA|S, S|C, // FDIV double
EA|S, S|C, // FDIVR double
// 0xDD
EA, S|C, // FLD double
S, EA|S|C, // FISTTP long
S, EA|C, // FST double
S, EA|S|C, // FSTP double
N, N, // FRSTOR
N, N, //
N, N, // FSAVE
C, EA, // FSTSW
// 0xDE
EA|S, S|C, // FIADD short
EA|S, S|C, // FIMUL short
EA|S, C, // FICOM short
EA|S, S|C, // FICOMP short
EA|S, S|C, // FISUB short
EA|S, S|C, // FISUBR short
EA|S, S|C, // FIDIV short
EA|S, S|C, // FIDIVR short
// 0xDF
EA, S|C, // FILD short
S, EA|S|C, // FISTTP short
S, EA|C, // FIST short
S, EA|S|C, // FISTP short
EA, S|C, // FBLD packed BCD
EA, S|C, // FILD long long
S, EA|S|C, // FBSTP packed BCD
S, EA|S|C, // FISTP long long
};
/********************************************
* Micro-ops for floating point opcodes 0xD8..0xDF, with Irm < 0xC0.
*/
static unsigned char uopsgrpf1[8][8] =
{
// 0xD8
2, // FADD float
2, // FMUL float
2, // FCOM float
2, // FCOMP float
2, // FSUB float
2, // FSUBR float
2, // FDIV float
2, // FDIVR float
// 0xD9
1, // FLD float
0, //
2, // FST float
2, // FSTP float
5, // FLDENV
3, // FLDCW
5, // FSTENV
5, // FSTCW
// 0xDA
5, // FIADD long
5, // FIMUL long
5, // FICOM long
5, // FICOMP long
5, // FISUB long
5, // FISUBR long
5, // FIDIV long
5, // FIDIVR long
// 0xDB
4, // FILD long
0, //
4, // FIST long
4, // FISTP long
0, //
4, // FLD real80
0, //
5, // FSTP real80
// 0xDC
2, // FADD double
2, // FMUL double
2, // FCOM double
2, // FCOMP double
2, // FSUB double
2, // FSUBR double
2, // FDIV double
2, // FDIVR double
// 0xDD
1, // FLD double
0, //
2, // FST double
2, // FSTP double
5, // FRSTOR
0, //
5, // FSAVE
5, // FSTSW
// 0xDE
5, // FIADD short
5, // FIMUL short
5, // FICOM short
5, // FICOMP short
5, // FISUB short
5, // FISUBR short
5, // FIDIV short
5, // FIDIVR short
// 0xDF
4, // FILD short
0, //
4, // FIST short
4, // FISTP short
5, // FBLD packed BCD
4, // FILD long long
5, // FBSTP packed BCD
4, // FISTP long long
};
/**************************************************
* Determine number of micro-ops for Pentium Pro and Pentium II processors.
* 0 means special case,
* 5 means 'complex'
*/
static const unsigned char insuops[256] =
{ 0,0,0,0, 1,1,4,5, /* 00 */
0,0,0,0, 1,1,4,0, /* 08 */
0,0,0,0, 2,2,4,5, /* 10 */
0,0,0,0, 2,2,4,5, /* 18 */
0,0,0,0, 1,1,0,1, /* 20 */
0,0,0,0, 1,1,0,1, /* 28 */
0,0,0,0, 1,1,0,1, /* 30 */
0,0,0,0, 1,1,0,1, /* 38 */
1,1,1,1, 1,1,1,1, /* 40 */
1,1,1,1, 1,1,1,1, /* 48 */
3,3,3,3, 3,3,3,3, /* 50 */
2,2,2,2, 3,2,2,2, /* 58 */
5,5,5,5, 0,0,0,0, /* 60 */
3,3,0,0, 5,5,5,5, /* 68 */
1,1,1,1, 1,1,1,1, /* 70 */
1,1,1,1, 1,1,1,1, /* 78 */
0,0,0,0, 0,0,0,0, /* 80 */
0,0,0,0, 0,1,4,0, /* 88 */
1,3,3,3, 3,3,3,3, /* 90 */
1,1,5,0, 5,5,1,1, /* 98 */
1,1,2,2, 5,5,5,5, /* A0 */
1,1,3,3, 2,2,3,3, /* A8 */
1,1,1,1, 1,1,1,1, /* B0 */
1,1,1,1, 1,1,1,1, /* B8 */
0,0,5,4, 0,0,0,0, /* C0 */
5,3,5,5, 5,3,5,5, /* C8 */
0,0,0,0, 4,3,0,2, /* D0 */
0,0,0,0, 0,0,0,0, /* D8 */
4,4,4,2, 5,5,5,5, /* E0 */
4,1,5,1, 5,5,5,5, /* E8 */
0,0,5,5, 5,1,0,0, /* F0 */
1,1,5,5, 4,4,0,0, /* F8 */
};
static unsigned char uopsx[8] = { 1,1,2,5,1,1,1,5 };
/************************************************
* Determine number of micro-ops for Pentium Pro and Pentium II processors.
* 5 means 'complex'.
* Doesn't currently handle:
* floating point
* MMX
* 0F opcodes
* prefix bytes
*/
STATIC int uops(code *c)
{ int n;
int op;
int op2;
op = c->Iop & 0xFF;
if ((c->Iop & 0xFF00) == 0x0F00)
op = 0x0F;
n = insuops[op];
if (!n) // if special case
{ unsigned char irm,mod,reg,rm;
irm = c->Irm;
mod = (irm >> 6) & 3;
reg = (irm >> 3) & 7;
rm = irm & 7;
switch (op)
{
case 0x10:
case 0x11: // ADC rm,r
case 0x18:
case 0x19: // SBB rm,r
n = (mod == 3) ? 2 : 4;
break;
case 0x12:
case 0x13: // ADC r,rm
case 0x1A:
case 0x1B: // SBB r,rm
n = (mod == 3) ? 2 : 3;
break;
case 0x00:
case 0x01: // ADD rm,r
case 0x08:
case 0x09: // OR rm,r
case 0x20:
case 0x21: // AND rm,r
case 0x28:
case 0x29: // SUB rm,r
case 0x30:
case 0x31: // XOR rm,r
n = (mod == 3) ? 1 : 4;
break;
case 0x02:
case 0x03: // ADD r,rm
case 0x0A:
case 0x0B: // OR r,rm
case 0x22:
case 0x23: // AND r,rm
case 0x2A:
case 0x2B: // SUB r,rm
case 0x32:
case 0x33: // XOR r,rm
case 0x38:
case 0x39: // CMP rm,r
case 0x3A:
case 0x3B: // CMP r,rm
case 0x69: // IMUL rm,r,imm
case 0x6B: // IMUL rm,r,imm8
case 0x84:
case 0x85: // TEST rm,r
n = (mod == 3) ? 1 : 2;
break;
case 0x80:
case 0x81:
case 0x82:
case 0x83:
if (reg == 2 || reg == 3) // ADC/SBB rm,imm
n = (mod == 3) ? 2 : 4;
else if (reg == 7) // CMP rm,imm
n = (mod == 3) ? 1 : 2;
else
n = (mod == 3) ? 1 : 4;
break;
case 0x86:
case 0x87: // XCHG rm,r
n = (mod == 3) ? 3 : 5;
break;
case 0x88:
case 0x89: // MOV rm,r
n = (mod == 3) ? 1 : 2;
break;
case 0x8A:
case 0x8B: // MOV r,rm
n = 1;
break;
case 0x8C: // MOV Sreg,rm
n = (mod == 3) ? 1 : 3;
break;
case 0x8F:
if (reg == 0) // POP m
n = 5;
break;
case 0xC6:
case 0xC7:
if (reg == 0) // MOV rm,imm
n = (mod == 3) ? 1 : 2;
break;
case 0xD0:
case 0xD1:
if (reg == 2 || reg == 3) // RCL/RCR rm,1
n = (mod == 3) ? 2 : 4;
else
n = (mod == 3) ? 1 : 4;
break;
case 0xC0:
case 0xC1: // RCL/RCR rm,imm8
case 0xD2:
case 0xD3:
if (reg == 2 || reg == 3) // RCL/RCR rm,CL
n = 5;
else
n = (mod == 3) ? 1 : 4;
break;
case 0xD8:
case 0xD9:
case 0xDA:
case 0xDB:
case 0xDC:
case 0xDD:
case 0xDE:
case 0xDF:
// Floating point opcodes
if (irm < 0xC0)
{ n = uopsgrpf1[op - 0xD8][reg];
break;
}
n = uopsx[op - 0xD8];
switch (op)
{
case 0xD9:
switch (irm)
{
case 0xE0: // FCHS
n = 3;
break;
case 0xE8:
case 0xE9:
case 0xEA:
case 0xEB:
case 0xEC:
case 0xED:
n = 2;
break;
case 0xF0:
case 0xF1:
case 0xF2:
case 0xF3:
case 0xF4:
case 0xF5:
case 0xF8:
case 0xF9:
case 0xFB:
case 0xFC:
case 0xFD:
case 0xFE:
case 0xFF:
n = 5;
break;
}
break;
case 0xDE:
if (irm == 0xD9) // FCOMPP
n = 2;
break;
}
break;
case 0xF6:
if (reg == 6 || reg == 7) // DIV AL,rm8
n = (mod == 3) ? 3 : 4;
else if (reg == 4 || reg == 5 || reg == 0) // MUL/IMUL/TEST rm8
n = (mod == 3) ? 1 : 2;
else if (reg == 2 || reg == 3) // NOT/NEG rm
n = (mod == 3) ? 1 : 4;
break;
case 0xF7:
if (reg == 6 || reg == 7) // DIV EAX,rm
n = 4;
else if (reg == 4 || reg == 5) // MUL/IMUL rm
n = (mod == 3) ? 3 : 4;
else if (reg == 2 || reg == 3) // NOT/NEG rm
n = (mod == 3) ? 1 : 4;
break;
case 0xFF:
if (reg == 2 || reg == 3 || // CALL rm, CALL m,rm
reg == 5) // JMP seg:offset
n = 5;
else if (reg == 4)
n = (mod == 3) ? 1 : 2;
else if (reg == 0 || reg == 1) // INC/DEC rm
n = (mod == 3) ? 1 : 4;
else if (reg == 6) // PUSH rm
n = (mod == 3) ? 3 : 4;
break;
case 0x0F:
op2 = c->Iop & 0xFF;
if ((op2 & 0xF0) == 0x80) // Jcc
{ n = 1;
break;
}
if ((op2 & 0xF0) == 0x90) // SETcc
{ n = (mod == 3) ? 1 : 3;
break;
}
if (op2 == 0xB6 || op2 == 0xB7 || // MOVZX
op2 == 0xBE || op2 == 0xBF) // MOVSX
{ n = 1;
break;
}
if (op2 == 0xAF) // IMUL r,m
{ n = (mod == 3) ? 1 : 2;
break;
}
break;
}
}
if (n == 0)
n = 5; // copout for now
return n;
}
/******************************************
* Determine pairing classification.
* Don't deal with floating point, just assume they are all NP (Not Pairable).
* Returns:
* NP,UV,PU,PV optionally OR'd with PE
*/
STATIC int pair_class(code *c)
{ unsigned char op;
unsigned char irm,mod,reg,rm;
unsigned a32;
int pc;
// Of course, with Intel this is *never* simple, and Intel's
// documentation is vague about the specifics.
op = c->Iop & 0xFF;
if ((c->Iop & 0xFF00) == 0x0F00)
op = 0x0F;
pc = pentcycl[op];
a32 = I32;
if (c->Iflags & CFaddrsize)
a32 ^= 1;
irm = c->Irm;
mod = (irm >> 6) & 3;
reg = (irm >> 3) & 7;
rm = irm & 7;
switch (op)
{
case 0x0F: // 2 byte opcode
if ((c->Iop & 0xF0) == 0x80) // if Jcc
pc = PV | PF;
break;
case 0x80:
case 0x81:
case 0x83:
if (reg == 2 || // ADC EA,immed
reg == 3) // SBB EA,immed
{ pc = PU;
goto L2;
}
goto L1; // AND/OR/XOR/ADD/SUB/CMP EA,immed
case 0x84:
case 0x85: // TEST EA,reg
if (mod == 3) // TEST reg,reg
pc = UV;
break;
case 0xC0:
case 0xC1:
if (reg >= 4)
pc = PU;
break;
case 0xC6:
case 0xC7:
if (reg == 0) // MOV EA,immed
{
L1:
pc = UV;
L2:
// if EA contains a displacement then
// can't execute in V, or pair in U
switch (mod)
{ case 0:
if (a32)
{ if (rm == 5 ||
(rm == 4 && (c->Isib & 7) == 5)
)
pc = NP;
}
else if (rm == 6)
pc = NP;
break;
case 1:
case 2:
pc = NP;
break;
}
}
break;
case 0xD9:
if (irm < 0xC0)
{
if (reg == 0)
pc = FX;
}
else if (irm < 0xC8)
pc = FX;
else if (irm < 0xD0)
pc = PV;
else
{
switch (irm)
{
case 0xE0:
case 0xE1:
case 0xE4:
pc = FX;
break;
}
}
break;
case 0xDB:
if (irm < 0xC0 && (reg == 0 || reg == 5))
pc = FX;
break;
case 0xDD:
if (irm < 0xC0)
{
if (reg == 0)
pc = FX;
}
else if (irm >= 0xE0 && irm < 0xF0)
pc = FX;
break;
case 0xDF:
if (irm < 0xC0 && (reg == 0 || reg == 5))
pc = FX;
break;
case 0xFE:
if (reg == 0 || reg == 1) // INC/DEC EA
pc = UV;
break;
case 0xFF:
if (reg == 0 || reg == 1) // INC/DEC EA
pc = UV;
else if (reg == 2 || reg == 4) // CALL/JMP near ptr EA
pc = PE|PV;
else if (reg == 6 && mod == 3) // PUSH reg
pc = PE | UV;
break;
}
if (c->Iflags & CFPREFIX && pc == UV) // if prefix byte
pc = PU;
return pc;
}
/******************************************
* For an instruction, determine what is read
* and what is written, and what is used for addressing.
* Determine operand size if EA (larger is ok).
*/
STATIC void getinfo(Cinfo *ci,code *c)
{
memset(ci,0,sizeof(Cinfo));
if (!c)
return;
ci->c = c;
if (PRO)
{
ci->uops = uops(c);
ci->isz = calccodsize(c);
}
else
ci->pair = pair_class(c);
unsigned char op;
unsigned char op2;
unsigned char irm,mod,reg,rm;
unsigned a32;
int pc;
unsigned r,w;
int sz = I32 ? 4 : 2;
ci->r = 0;
ci->w = 0;
ci->a = 0;
op = c->Iop & 0xFF;
if ((c->Iop & 0xFF00) == 0x0F00)
op = 0x0F;
//printf("\tgetinfo %x, op %x \n",c,op);
pc = pentcycl[op];
a32 = I32;
if (c->Iflags & CFaddrsize)
a32 ^= 1;
if (c->Iflags & CFopsize)
sz ^= 2 | 4;
irm = c->Irm;
mod = (irm >> 6) & 3;
reg = (irm >> 3) & 7;
rm = irm & 7;
r = oprw[op][0];
w = oprw[op][1];
switch (op)
{
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x55:
case 0x56:
case 0x57: // PUSH reg
ci->flags |= CIFLpush;
case 0x54: // PUSH ESP
case 0x6A: // PUSH imm8
case 0x68: // PUSH imm
case 0x0E:
case 0x16:
case 0x1E:
case 0x06:
case 0x9C:
Lpush:
ci->spadjust = -sz;
ci->a |= mSP;
break;
case 0x58:
case 0x59:
case 0x5A:
case 0x5B:
case 0x5C:
case 0x5D:
case 0x5E:
case 0x5F: // POP reg
case 0x1F:
case 0x07:
case 0x17:
case 0x9D: // POPF
Lpop:
ci->spadjust = sz;
ci->a |= mSP;
break;
case 0x80:
if (reg == 7) // CMP
c->Iflags |= CFpsw;
r = B | grprw[0][reg][0]; // Grp 1 (byte)
w = B | grprw[0][reg][1];
break;
case 0x81:
case 0x83:
if (reg == 7) // CMP
c->Iflags |= CFpsw;
else if (irm == modregrm(3,0,SP)) // ADD ESP,imm
{
assert(c->IFL2 == FLconst);
ci->spadjust = (op == 0x81) ? c->IEV2.Vint : (signed char)c->IEV2.Vint;
}
else if (irm == modregrm(3,5,SP)) // SUB ESP,imm
{
assert(c->IFL2 == FLconst);
ci->spadjust = (op == 0x81) ? -c->IEV2.Vint : -(signed char)c->IEV2.Vint;
}
r = grprw[0][reg][0]; // Grp 1
w = grprw[0][reg][1];
break;
case 0x8F:
if (reg == 0) // POP rm
goto Lpop;
break;
case 0xA0:
case 0xA1:
case 0xA2:
case 0xA3:
// Fake having an EA to simplify code in conflict()
ci->flags |= CIFLea;
ci->reg = 0;
ci->sibmodrm = a32 ? modregrm(0,0,5) : modregrm(0,0,6);
c->IFL1 = c->IFL2;
c->IEV1 = c->IEV2;
break;
case 0xC2:
case 0xC3:
case 0xCA:
case 0xCB: // RET
ci->a |= mSP;
break;
case 0xE8:
if (c->Iflags & CFclassinit) // call to __j_classinit
{ r = 0;
w = F;
#if CLASSINIT2
ci->pair = UV; // it is patched to CMP EAX,0
#else
ci->pair = NP;
#endif
}
break;
case 0xF6:
r = grprw[3][reg][0]; // Grp 3, byte version
w = grprw[3][reg][1];
break;
case 0xF7:
r = grprw[1][reg][0]; // Grp 3
w = grprw[1][reg][1];
break;
case 0x0F:
op2 = c->Iop & 0xFF;
if ((op2 & 0xF0) == 0x80) // if Jxx instructions
{
ci->r = F | N;
ci->w = N;
goto Lret;
}
ci->r = N;
ci->w = N; // copout for now
goto Lret;
case 0xD7: // XLAT
ci->a = mAX | mBX;
break;
case 0xFF:
r = grprw[2][reg][0]; // Grp 5
w = grprw[2][reg][1];
if (reg == 6) // PUSH rm
goto Lpush;
break;
case 0x38:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3C: // CMP AL,imm8
case 0x3D: // CMP EAX,imm32
// For CMP opcodes, always test for flags
c->Iflags |= CFpsw;
break;
case ESCAPE:
if (c->Iop == (ESCAPE | ESCadjfpu))
ci->fpuadjust = c->IEV1.Vint;
break;
case 0xD0:
case 0xD1:
case 0xD2:
case 0xD3:
case 0xC0:
case 0xC1:
if (reg == 2 || reg == 3) // if RCL or RCR
c->Iflags |= CFpsw; // always test for flags
break;
case 0xD8:
case 0xD9:
case 0xDA:
case 0xDB:
case 0xDC:
case 0xDD:
case 0xDE:
case 0xDF:
if (irm < 0xC0)
{ r = grpf1[op - 0xD8][reg][0];
w = grpf1[op - 0xD8][reg][1];
switch (op)
{
case 0xD8:
if (reg == 3) // if FCOMP
ci->fpuadjust = -1;
else
ci->fp_op = FPfop;
break;
case 0xD9:
if (reg == 0) // if FLD float
{ ci->fpuadjust = 1;
ci->fp_op = FPfld;
}
else if (reg == 3) // if FSTP float
{ ci->fpuadjust = -1;
ci->fp_op = FPfstp;
}
else if (reg == 5 || reg == 7)
sz = 2;
else if (reg == 4 || reg == 6)
sz = 28;
break;
case 0xDA:
if (reg == 3) // if FICOMP
ci->fpuadjust = -1;
break;
case 0xDB:
if (reg == 0 || reg == 5)
{ ci->fpuadjust = 1;
ci->fp_op = FPfld; // FILD / FLD long double
}
if (reg == 3 || reg == 7)
ci->fpuadjust = -1;
if (reg == 7)
ci->fp_op = FPfstp; // FSTP long double
if (reg == 5 || reg == 7)
sz = 10;
break;
case 0xDC:
sz = 8;
if (reg == 3) // if FCOMP
ci->fpuadjust = -1;
else
ci->fp_op = FPfop;
break;
case 0xDD:
if (reg == 0) // if FLD double
{ ci->fpuadjust = 1;
ci->fp_op = FPfld;
}
if (reg == 3) // if FSTP double
{ ci->fpuadjust = -1;
ci->fp_op = FPfstp;
}
if (reg == 7)
sz = 2;
else if (reg == 4 || reg == 6)
sz = 108;
else
sz = 8;
break;
case 0xDE:
sz = 2;
if (reg == 3) // if FICOMP
ci->fpuadjust = -1;
break;
case 0xDF:
sz = 2;
if (reg == 4 || reg == 6)
sz = 10;
else if (reg == 5 || reg == 7)
sz = 8;
if (reg == 0 || reg == 4 || reg == 5)
ci->fpuadjust = 1;
else if (reg == 3 || reg == 6 || reg == 7)
ci->fpuadjust = -1;
break;
}
break;
}
else if (op == 0xDE)
{ ci->fpuadjust = -1; // pop versions of Fop's
if (irm == 0xD9)
ci->fpuadjust = -2; // FCOMPP
}
// Most floating point opcodes aren't staged, but are
// sent right through, in order to make use of the large
// latencies with floating point instructions.
if (ci->fp_op == FPfld ||
(op == 0xD9 && (irm & 0xF8) == 0xC0))
; // FLD ST(i)
else
ci->flags |= CIFLnostage;
switch (op)
{
case 0xD8:
r = S;
w = C;
if ((irm & ~7) == 0xD0)
w |= S;
break;
case 0xD9:
// FCHS or FABS or FSQRT
if (irm == 0xE0 || irm == 0xE1 || irm == 0xFA)
ci->fp_op = FPfop;
r = S;
w = S|C;
break;
case 0xDA:
if (irm == 0xE9) // FUCOMPP
{ r = S;
w = S|C;
break;
}
break;
case 0xDB:
if (irm == 0xE2) // FCLEX
{ r = 0;
w = C;
break;
}
if (irm == 0xE3) // FINIT
{ r = 0;
w = S|C;
break;
}
break;
case 0xDC:
case 0xDE:
if ((irm & 0xF0) != 0xD0)
{ r = S;
w = S|C;
break;
}
break;
case 0xDD:
// Not entirely correct, but conservative
r = S;
w = S|C;
break;
case 0xDF:
if (irm == 0xE0) // FSTSW AX
{ r = C;
w = mAX;
break;
}
break;
}
break;
#if DEBUG
default:
//printf("\t\tNo special case\n");
break;
#endif
}
if ((r | w) & B) // if byte operation
sz = 1; // operand size is 1
ci->r = r & ~(R | EA);
ci->w = w & ~(R | EA);
if (r & R)
ci->r |= mask[(r & B) ? (reg & 3) : reg];
if (w & R)
ci->w |= mask[(w & B) ? (reg & 3) : reg];
// OR in bits for EA addressing mode
if ((r | w) & EA)
{ unsigned char sib;
sib = 0;
switch (mod)
{
case 0:
if (a32)
{
if (rm == 4)
{ sib = c->Isib;
if ((sib & modregrm(0,7,0)) != modregrm(0,4,0))
ci->a |= mask[(sib >> 3) & 7]; // index register
if ((sib & 7) != 5)
ci->a |= mask[sib & 7]; // base register
}
else if (rm != 5)
ci->a |= mask[rm];
}
else
{ static unsigned char ea16[8] = {mBX|mSI,mBX|mDI,mBP|mSI,mBP|mDI,mSI,mDI,0,mBX};
ci->a |= ea16[rm];
}
goto Lmem;
case 1:
case 2:
if (a32)
{
if (rm == 4)
{ sib = c->Isib;
if ((sib & modregrm(0,7,0)) != modregrm(0,4,0))
ci->a |= mask[(sib >> 3) & 7]; // index register
ci->a |= mask[sib & 7]; // base register
}
else
ci->a |= mask[rm];
}
else
{ static unsigned char ea16[8] = {mBX|mSI,mBX|mDI,mBP|mSI,mBP|mDI,mSI,mDI,mBP,mBX};
ci->a |= ea16[rm];
}
Lmem:
if (r & EA)
ci->r |= mMEM;
if (w & EA)
ci->w |= mMEM;
ci->flags |= CIFLea;
break;
case 3:
if (r & EA)
ci->r |= mask[(r & B) ? (rm & 3) : rm];
if (w & EA)
ci->w |= mask[(w & B) ? (rm & 3) : rm];
break;
}
// Adjust sibmodrm so that addressing modes can be compared simply
irm &= modregrm(3,0,7);
if (a32)
{
if (irm != modregrm(0,0,5))
{
switch (mod)
{ case 0:
if ((sib & 7) != 5) // if not disp32[index]
{ c->IFL1 = FLconst;
c->IEVpointer1 = 0;
irm |= 0x80;
}
break;
case 1:
c->IEVpointer1 = (signed char) c->IEVpointer1;
irm = modregrm(2,0,rm);
break;
}
}
}
else
{
if (irm != modregrm(0,0,6))
{
switch (mod)
{ case 0:
c->IFL1 = FLconst;
c->IEVpointer1 = 0;
irm |= 0x80;
break;
case 1:
c->IEVpointer1 = (signed char) c->IEVpointer1;
irm = modregrm(2,0,rm);
break;
}
}
}
ci->r |= ci->a;
ci->reg = reg;
ci->sibmodrm = (sib << 8) | irm;
}
Lret:
if (ci->w & mSP) // if stack pointer is modified
ci->w |= mMEM; // then we are implicitly writing to memory
if (op == 0x8D) // if LEA
ci->r &= ~mMEM; // memory is not actually read
ci->sz = sz;
#if DEBUG
//printf("\t\t"); ci->print();
#endif
}
/******************************************
* Determine if two instructions can pair.
* Assume that in general, cu can pair in the U pipe and cv in the V.
* Look for things like register contentions.
* Input:
* cu instruction for U pipe
* cv instruction for V pipe
* Returns:
* !=0 if they can pair
*/
STATIC int pair_test(Cinfo *cu,Cinfo *cv)
{ unsigned pcu;
unsigned pcv;
unsigned r1,w1;
unsigned r2,w2;
unsigned x;
pcu = cu->pair;
if (!(pcu & PU))
{
// See if pairs with FXCH and cv is FXCH
if (pcu & FX && cv->c->Iop == 0xD9 && (cv->c->Irm & ~7) == 0xC8)
goto Lpair;
goto Lnopair;
}
pcv = cv->pair;
if (!(pcv & PV))
goto Lnopair;
r1 = cu->r;
w1 = cu->w;
r2 = cv->r;
w2 = cv->w;
x = w1 & (r2 | w2) & ~(F|mMEM); // register contention
if (x && // if register contention
!(x == mSP && pcu & pcv & PE) // and not exception
)
goto Lnopair;
// Look for flags contention
if (w1 & r2 & F && !(pcv & PF))
goto Lnopair;
Lpair:
return 1;
Lnopair:
return 0;
}
/******************************************
* Determine if two instructions have an AGI or register contention.
* Returns:
* !=0 if they have an AGI
*/
STATIC int pair_agi(Cinfo *c1,Cinfo *c2)
{ unsigned x;
x = c1->w & c2->a;
return x && !(x == mSP && c1->pair & c2->pair & PE);
}
/********************************************
* Determine if three instructions can decode simultaneously
* in Pentium Pro and Pentium II.
* Input:
* c0,c1,c2 candidates for decoders 0,1,2
* c2 can be NULL
* Returns:
* !=0 if they can decode simultaneously
*/
STATIC int triple_test(Cinfo *c0,Cinfo *c1,Cinfo *c2)
{ int c2isz;
assert(c0);
if (!c1)
goto Lnopair;
c2isz = c2 ? c2->isz : 0;
if (c0->isz > 7 || c1->isz > 7 || c2isz > 7 ||
c0->isz + c1->isz + c2isz > 16)
goto Lnopair;
// 4-1-1 decode
if (c1->uops > 1 ||
(c2 && c2->uops > 1))
goto Lnopair;
Lpair:
return 1;
Lnopair:
return 0;
}
/********************************************
* Get next instruction worth looking at for scheduling.
* Returns:
* NULL no more instructions
*/
STATIC code * cnext(code *c)
{
while (1)
{
c = code_next(c);
if (!c)
break;
if (c->Iflags & (CFtarg | CFtarg2))
break;
if (!(c->Iop == NOP ||
c->Iop == (ESCAPE | ESClinnum)))
break;
}
return c;
}
/******************************************
* Instruction scheduler.
* Input:
* c list of instructions to schedule
* scratch scratch registers we can use
* Returns:
* revised list of scheduled instructions
*/
///////////////////////////////////
// Determine if c1 and c2 are swappable.
// c1 comes before c2.
// If they do not conflict
// return 0
// If they do conflict
// return 0x100 + delay_clocks
// Input:
// fpsched if 1, then adjust fxch_pre and fxch_post to swap,
// then return 0
// if 2, then adjust ci1 as well as ci2
STATIC int conflict(Cinfo *ci1,Cinfo *ci2,int fpsched)
{
code *c1;
code *c2;
unsigned r1,w1,a1;
unsigned r2,w2,a2;
int sz1,sz2;
int i = 0;
int delay_clocks;
c1 = ci1->c;
c2 = ci2->c;
//printf("conflict %x %x\n",c1,c2);
r1 = ci1->r;
w1 = ci1->w;
a1 = ci1->a;
sz1 = ci1->sz;
r2 = ci2->r;
w2 = ci2->w;
a2 = ci2->a;
sz2 = ci2->sz;
//printf("r1 %lx w1 %lx a1 %lx sz1 %x\n",r1,w1,a1,sz1);
//printf("r2 %lx w2 %lx a2 %lx sz2 %x\n",r2,w2,a2,sz2);
if ((c1->Iflags | c2->Iflags) & (CFvolatile | CFvex))
goto Lconflict;
// Determine if we should handle FPU register conflicts separately
//if (fpsched) printf("fp_op %d,%d:\n",ci1->fp_op,ci2->fp_op);
if (fpsched && ci1->fp_op && ci2->fp_op)
{
w1 &= ~(S|C);
r1 &= ~(S|C);
w2 &= ~(S|C);
r2 &= ~(S|C);
}
else
fpsched = 0;
if ((r1 | r2) & N)
{
goto Lconflict;
}
#if 0
if (c1->Iop == 0xFF && c2->Iop == 0x8B)
{ c1->print(); c2->print(); i = 1;
printf("r1=%lx, w1=%lx, a1=%lx, sz1=%d, r2=%lx, w2=%lx, a2=%lx, sz2=%d\n",r1,w1,a1,sz1,r2,w2,a2,sz2);
}
#endif
L1:
if (w1 & r2 || (r1 | w1) & w2)
{ unsigned char ifl1,ifl2;
if (i) printf("test\n");
#if 0
if (c1->IFL1 != c2->IFL1) printf("t1\n");
if ((c1->Irm & modregrm(3,0,7)) != (c2->Irm & modregrm(3,0,7))) printf("t2\n");
if ((issib(c1->Irm) && c1->Isib != c2->Isib)) printf("t3\n");
if (c1->IEVpointer1 + sz1 <= c2->IEVpointer1) printf("t4\n");
if (c2->IEVpointer1 + sz2 <= c1->IEVpointer1) printf("t5\n");
#endif
#if 1 // make sure CFpsw is reliably set
if (w1 & w2 & F && // if both instructions write to flags
w1 != F &&
w2 != F &&
!((r1 | r2) & F) && // but neither instruction reads them
!((c1->Iflags | c2->Iflags) & CFpsw)) // and we don't care about flags
{
w1 &= ~F;
w2 &= ~F; // remove conflict
goto L1; // and try again
}
#endif
// If other than the memory reference is a conflict
if (w1 & r2 & ~mMEM || (r1 | w1) & w2 & ~mMEM)
{ if (i) printf("\t1\n");
if (i) printf("r1=%x, w1=%x, a1=%x, sz1=%d, r2=%x, w2=%x, a2=%x, sz2=%d\n",r1,w1,a1,sz1,r2,w2,a2,sz2);
goto Lconflict;
}
// If referring to distinct types, then no dependency
if (c1->Irex && c2->Irex && c1->Irex != c2->Irex)
goto Lswap;
ifl1 = c1->IFL1;
ifl2 = c2->IFL1;
// Special case: Allow indexed references using registers other than
// ESP and EBP to be swapped with PUSH instructions
if (((c1->Iop & ~7) == 0x50 || // PUSH reg
c1->Iop == 0x6A || // PUSH imm8
c1->Iop == 0x68 || // PUSH imm16/imm32
(c1->Iop == 0xFF && ci1->reg == 6) // PUSH EA
) &&
ci2->flags & CIFLea && !(a2 & mSP) &&
!(a2 & mBP && (long)c2->IEVpointer1 < 0)
)
{
if (c1->Iop == 0xFF)
{
if (!(w2 & mMEM))
goto Lswap;
}
else
goto Lswap;
}
// Special case: Allow indexed references using registers other than
// ESP and EBP to be swapped with PUSH instructions
if (((c2->Iop & ~7) == 0x50 || // PUSH reg
c2->Iop == 0x6A || // PUSH imm8
c2->Iop == 0x68 || // PUSH imm16/imm32
(c2->Iop == 0xFF && ci2->reg == 6) // PUSH EA
) &&
ci1->flags & CIFLea && !(a1 & mSP) &&
!(a2 & mBP && (long)c2->IEVpointer1 < 0)
)
{
if (c2->Iop == 0xFF)
{
if (!(w1 & mMEM))
goto Lswap;
}
else
goto Lswap;
}
// If not both an EA addressing mode, conflict
if (!(ci1->flags & ci2->flags & CIFLea))
{ if (i) printf("\t2\n");
goto Lconflict;
}
if (ci1->sibmodrm == ci2->sibmodrm)
{ if (ifl1 != ifl2)
goto Lswap;
switch (ifl1)
{
case FLconst:
if (c1->IEV1.Vint != c2->IEV1.Vint &&
(c1->IEV1.Vint + sz1 <= c2->IEV1.Vint ||
c2->IEV1.Vint + sz2 <= c1->IEV1.Vint))
goto Lswap;
break;
case FLdatseg:
if (c1->IEVseg1 != c2->IEVseg1 ||
c1->IEV1.Vint + sz1 <= c2->IEV1.Vint ||
c2->IEV1.Vint + sz2 <= c1->IEV1.Vint)
goto Lswap;
break;
}
}
if ((c1->Iflags | c2->Iflags) & CFunambig &&
(ifl1 != ifl2 ||
ci1->sibmodrm != ci2->sibmodrm ||
(c1->IEV1.Vint != c2->IEV1.Vint &&
(c1->IEV1.Vint + sz1 <= c2->IEV1.Vint ||
c2->IEV1.Vint + sz2 <= c1->IEV1.Vint)
)
)
)
{
// Assume that [EBP] and [ESP] can point to the same location
if (((a1 | a2) & (mBP | mSP)) == (mBP | mSP))
goto Lconflict;
goto Lswap;
}
if (i) printf("\t3\n");
goto Lconflict;
}
Lswap:
if (fpsched)
{
//printf("\tfpsched %d,%d:\n",ci1->fp_op,ci2->fp_op);
unsigned char x1 = ci1->fxch_pre;
unsigned char y1 = ci1->fxch_post;
unsigned char x2 = ci2->fxch_pre;
unsigned char y2 = ci2->fxch_post;
#define X(a,b) ((a << 8) | b)
switch (X(ci1->fp_op,ci2->fp_op))
{
case X(FPfstp,FPfld):
if (x1 || y1)
goto Lconflict;
if (x2)
goto Lconflict;
if (y2 == 0)
ci2->fxch_post++;
else if (y2 == 1)
{
ci2->fxch_pre++;
ci2->fxch_post++;
}
else
{
goto Lconflict;
}
break;
case X(FPfstp,FPfop):
if (x1 || y1)
goto Lconflict;
ci2->fxch_pre++;
ci2->fxch_post++;
break;
case X(FPfop,FPfop):
if (x1 == 0 && y1 == 1 && x2 == 0 && y2 == 0)
{ ci2->fxch_pre = 1;
ci2->fxch_post = 1;
break;
}
if (x1 == 0 && y1 == 0 && x2 == 1 && y2 == 1)
break;
goto Lconflict;
case X(FPfop,FPfld):
if (x1 || y1)
goto Lconflict;
if (x2)
goto Lconflict;
if (y2)
break;
else if (fpsched == 2)
ci1->fxch_post = 1;
ci2->fxch_post = 1;
break;
default:
goto Lconflict;
}
#undef X
//printf("\tpre = %d, post = %d\n",ci2->fxch_pre,ci2->fxch_post);
}
//printf("w1 = x%x, w2 = x%x\n",w1,w2);
if (i) printf("no conflict\n\n");
return 0;
Lconflict:
//printf("r1=%x, w1=%x, r2=%x, w2=%x\n",r1,w1,r2,w2);
delay_clocks = 0;
// Determine if AGI
if (!PRO && pair_agi(ci1,ci2))
delay_clocks = 1;
// Special delays for floating point
if (fpsched)
{ if (ci1->fp_op == FPfld && ci2->fp_op == FPfstp)
delay_clocks = 1;
else if (ci1->fp_op == FPfop && ci2->fp_op == FPfstp)
delay_clocks = 3;
else if (ci1->fp_op == FPfop && ci2->fp_op == FPfop)
delay_clocks = 2;
}
else if (PRO)
{
// Look for partial register write stalls
if (w1 & r2 & ALLREGS && sz1 < sz2)
delay_clocks = 7;
}
else if ((w1 | r1) & (w2 | r2) & (C | S))
{ int reg;
int op;
op = c1->Iop;
reg = c1->Irm & modregrm(0,7,0);
if (ci1->fp_op == FPfld ||
(op == 0xD9 && (c1->Irm & 0xF8) == 0xC0)
)
; // FLD
else if (op == 0xD9 && (c1->Irm & 0xF8) == 0xC8)
; // FXCH
else if (c2->Iop == 0xD9 && (c2->Irm & 0xF8) == 0xC8)
; // FXCH
else
delay_clocks = 3;
}
if (i) printf("conflict %d\n\n",delay_clocks);
return 0x100 + delay_clocks;
}
struct Schedule
{
#define TBLMAX (2*3*20) // must be divisible by both 2 and 3
// (U,V pipe in Pentium, 3 decode units
// in Pentium Pro)
Cinfo *tbl[TBLMAX]; // even numbers are U pipe, odd numbers are V
int tblmax; // max number of slots used
Cinfo cinfo[TBLMAX];
int cinfomax;
list_t stagelist; // list of instructions in staging area
int fpustackused; // number of slots in FPU stack that are used
void initialize(int fpustackinit); // initialize scheduler
int stage(code *c); // stage instruction
int insert(Cinfo *ci); // insert c into schedule
code **assemble(code **pc); // reassemble scheduled instructions
};
/******************************
*/
void Schedule::initialize(int fpustackinit)
{
//printf("Schedule::initialize(fpustackinit = %d)\n", fpustackinit);
memset(this,0,sizeof(Schedule));
fpustackused = fpustackinit;
}
/******************************
*/
code **Schedule::assemble(code **pc)
{
code *c;
#ifdef DEBUG
if (debugs) printf("assemble:\n");
#endif
assert(!*pc);
// Try to insert the rest of the staged instructions
list_t l;
for (l = stagelist; l; l = list_next(l))
{
Cinfo* ci = (Cinfo *)list_ptr(l);
if (!insert(ci))
break;
}
// Get the instructions out of the schedule table
assert((unsigned)tblmax <= TBLMAX);
for (int i = 0; i < tblmax; i++)
{
Cinfo* ci = tbl[i];
#ifdef DEBUG
if (debugs)
{
if (PRO)
{ static char tbl[3][4] = { "0 "," 1 "," 2" };
if (ci)
printf("%s %d ",tbl[i - ((i / 3) * 3)],ci->uops);
else
printf("%s ",tbl[i - ((i / 3) * 3)]);
}
else
{
printf((i & 1) ? " V " : "U ");
}
if (ci)
ci->c->print();
else
printf("\n");
}
#endif
if (!ci)
continue;
fpustackused += ci->fpuadjust;
//printf("stage()1: fpustackused = %d\n", fpustackused);
c = ci->c;
if (i == 0)
c->Iflags |= CFtarg; // by definition, first is always a jump target
else
c->Iflags &= ~CFtarg; // the rest are not
// Put in any FXCH prefix
if (ci->fxch_pre)
{ code *cf;
assert(i);
cf = gen2(NULL,0xD9,0xC8 + ci->fxch_pre);
*pc = cf;
pc = &code_next(cf);
}
*pc = c;
do
{
assert(*pc != code_next(*pc));
pc = &code_next(*pc);
} while (*pc);
// Put in any FXCH postfix
if (ci->fxch_post)
{
for (int j = i + 1; j < tblmax; j++)
{ if (tbl[j])
{ if (tbl[j]->fxch_pre == ci->fxch_post)
{
tbl[j]->fxch_pre = 0; // they cancel each other out
goto L1;
}
break;
}
}
{ code *cf;
cf = gen2(NULL,0xD9,0xC8 + ci->fxch_post);
*pc = cf;
pc = &code_next(cf);
}
}
L1: ;
}
// Just append any instructions left in the staging area
for (; l; l = list_next(l))
{ Cinfo *ci = (Cinfo *)list_ptr(l);
#ifdef DEBUG
if (debugs) { printf("appending: "); ci->c->print(); }
#endif
*pc = ci->c;
do
{
pc = &code_next(*pc);
} while (*pc);
fpustackused += ci->fpuadjust;
//printf("stage()2: fpustackused = %d\n", fpustackused);
}
list_free(&stagelist);
return pc;
}
/******************************
* Insert c into scheduling table.
* Returns:
* 0 could not be scheduled; have to start a new one
*/
int Schedule::insert(Cinfo *ci)
{ code *c;
int clocks;
int i;
int ic = 0;
int imin;
targ_size_t offset;
targ_size_t vpointer;
int movesp = 0;
int reg2 = -1; // avoid "may be uninitialized" warning
//printf("insert "); ci->c->print();
//printf("insert() %d\n", fpustackused);
c = ci->c;
//printf("\tc->Iop %x\n",c->Iop);
vpointer = c->IEVpointer1;
assert((unsigned)tblmax <= TBLMAX);
if (tblmax == TBLMAX) // if out of space
goto Lnoinsert;
if (tblmax == 0) // if table is empty
{ // Just stuff it in the first slot
i = tblmax;
goto Linsert;
}
else if (c->Iflags & (CFtarg | CFtarg2))
// Jump targets can only be first in the scheduler
goto Lnoinsert;
// Special case of:
// PUSH reg1
// MOV reg2,x[ESP]
if (c->Iop == 0x8B &&
(c->Irm & modregrm(3,0,7)) == modregrm(1,0,4) &&
c->Isib == modregrm(0,4,SP) &&
c->IFL1 == FLconst &&
((signed char)c->IEVpointer1) >= REGSIZE
)
{
movesp = 1; // this is a MOV reg2,offset[ESP]
offset = (signed char)c->IEVpointer1;
reg2 = (c->Irm >> 3) & 7;
}
// Start at tblmax, and back up until we get a conflict
ic = -1;
imin = 0;
for (i = tblmax; i >= 0; i--)
{
Cinfo* cit = tbl[i];
if (!cit)
continue;
// Look for special case swap
if (movesp &&
(cit->c->Iop & ~7) == 0x50 && // if PUSH reg1
(cit->c->Iop & 7) != reg2 && // if reg1 != reg2
((signed char)c->IEVpointer1) >= -cit->spadjust
)
{
c->IEVpointer1 += cit->spadjust;
//printf("\t1, spadjust = %d, ptr = x%x\n",cit->spadjust,c->IEVpointer1);
continue;
}
if (movesp &&
cit->c->Iop == 0x83 &&
cit->c->Irm == modregrm(3,5,SP) && // if SUB ESP,offset
cit->c->IFL2 == FLconst &&
((signed char)c->IEVpointer1) >= -cit->spadjust
)
{
//printf("\t2, spadjust = %d\n",cit->spadjust);
c->IEVpointer1 += cit->spadjust;
continue;
}
clocks = conflict(cit,ci,1);
if (clocks)
{ int j;
ic = i; // where the conflict occurred
clocks &= 0xFF; // convert to delay count
// Move forward the delay clocks
if (clocks == 0)
j = i + 1;
else if (PRO)
j = (((i + 3) / 3) * 3) + clocks * 3;
else
{ j = ((i + 2) & ~1) + clocks * 2;
// It's possible we skipped over some AGI generating
// instructions due to movesp.
int k;
for (k = i + 1; k < j; k++)
{
if (k >= TBLMAX)
goto Lnoinsert;
if (tbl[k] && pair_agi(tbl[k],ci))
{
k = ((k + 2) & ~1) + 1;
}
}
j = k;
}
if (j >= TBLMAX) // exceed table size?
goto Lnoinsert;
imin = j; // first possible slot c can go in
break;
}
}
// Scan forward looking for a hole to put it in
for (i = imin; i < TBLMAX; i++)
{
if (tbl[i])
{
// In case, due to movesp, we skipped over some AGI instructions
if (!PRO && pair_agi(tbl[i],ci))
{
i = ((i + 2) & ~1) + 1;
if (i >= TBLMAX)
goto Lnoinsert;
}
}
else
{
if (PRO)
{ int i0 = (i / 3) * 3; // index of decode unit 0
Cinfo *ci0;
assert(((TBLMAX / 3) * 3) == TBLMAX);
switch (i - i0)
{
case 0: // i0 can handle any instruction
goto Linsert;
case 1:
ci0 = tbl[i0];
if (ci->uops > 1)
{
if (i0 >= imin && ci0->uops == 1)
goto L1;
i++;
break;
}
if (triple_test(ci0,ci,tbl[i0 + 2]))
goto Linsert;
break;
case 2:
ci0 = tbl[i0];
if (ci->uops > 1)
{
if (i0 >= imin && ci0->uops == 1)
{
if (i >= tblmax)
{ if (i + 1 >= TBLMAX)
goto Lnoinsert;
tblmax = i + 1;
}
tbl[i0 + 2] = tbl[i0 + 1];
tbl[i0 + 1] = ci0;
i = i0;
goto Linsert;
}
break;
}
if (triple_test(ci0,tbl[i0 + 1],ci))
goto Linsert;
break;
default:
assert(0);
}
}
else
{
assert((TBLMAX & 1) == 0);
if (i & 1) // if V pipe
{
if (pair_test(tbl[i - 1],ci))
{
goto Linsert;
}
else if (i > imin && pair_test(ci,tbl[i - 1]))
{
L1:
tbl[i] = tbl[i - 1];
if (i >= tblmax)
tblmax = i + 1;
i--;
//printf("\tswapping with x%02x\n",tbl[i + 1]->c->Iop);
goto Linsert;
}
}
else // will always fit in U pipe
{
assert(!tbl[i + 1]); // because V pipe should be empty
goto Linsert;
}
}
}
}
Lnoinsert:
//printf("\tnoinsert\n");
c->IEVpointer1 = vpointer; // reset to original value
return 0;
Linsert:
// Insert at location i
assert(i < TBLMAX);
assert(tblmax <= TBLMAX);
tbl[i] = ci;
//printf("\tinsert at location %d\n",i);
// If it's a scheduled floating point code, we have to adjust
// the FXCH values
if (ci->fp_op)
{
ci->fxch_pre = 0;
ci->fxch_post = 0; // start over again
int fpu = fpustackused;
for (int j = 0; j < tblmax; j++)
{
if (tbl[j])
{
fpu += tbl[j]->fpuadjust;
if (fpu >= 8) // if FPU stack overflow
{ tbl[i] = NULL;
//printf("fpu stack overflow\n");
goto Lnoinsert;
}
}
}
for (int j = tblmax; j > i; j--)
{
if (j < TBLMAX && tbl[j])
conflict(tbl[j],ci,2);
}
}
if (movesp)
{ // Adjust [ESP] offsets
//printf("\tic = %d, inserting at %d\n",ic,i);
assert((unsigned)tblmax <= TBLMAX);
for (int j = ic + 1; j < i; j++)
{
Cinfo* cit = tbl[j];
if (cit)
{
c->IEVpointer1 -= cit->spadjust;
//printf("\t3, spadjust = %d, ptr = x%x\n",cit->spadjust,c->IEVpointer1);
}
}
}
if (i >= tblmax)
tblmax = i + 1;
// Now do a hack. Look back at immediately preceding instructions,
// and see if we can swap with a push.
if (0 && movesp)
{
while (1)
{
int j;
for (j = 1; i > j; j++)
if (tbl[i - j])
break;
if (i >= j && tbl[i - j] &&
(tbl[i - j]->c->Iop & ~7) == 0x50 && // if PUSH reg1
(tbl[i - j]->c->Iop & 7) != reg2 && // if reg1 != reg2
(signed char)c->IEVpointer1 >= REGSIZE)
{
//printf("\t-4 prec, i-j=%d, i=%d\n",i-j,i);
assert((unsigned)i < TBLMAX);
assert((unsigned)(i - j) < TBLMAX);
tbl[i] = tbl[i - j];
tbl[i - j] = ci;
i -= j;
c->IEVpointer1 -= REGSIZE;
}
else
break;
}
}
//printf("\tinsert\n");
return 1;
}
/******************************
* Insert c into staging area.
* Returns:
* 0 could not be scheduled; have to start a new one
*/
int Schedule::stage(code *c)
{ Cinfo *ci;
list_t ln;
int agi;
//printf("stage: "); c->print();
if (cinfomax == TBLMAX) // if out of space
goto Lnostage;
ci = &cinfo[cinfomax++];
getinfo(ci,c);
if (c->Iflags & (CFtarg | CFtarg2 | CFvolatile | CFvex))
{
// Insert anything in stagelist
for (list_t l = stagelist; l; l = ln)
{
ln = list_next(l);
Cinfo* cs = (Cinfo *)list_ptr(l);
if (!insert(cs))
return 0;
list_subtract(&stagelist,cs);
}
return insert(ci);
}
// Look through stagelist, and insert any AGI conflicting instructions
agi = 0;
for (list_t l = stagelist; l; l = ln)
{
ln = list_next(l);
Cinfo* cs = (Cinfo *)list_ptr(l);
if (pair_agi(cs,ci))
{
if (!insert(cs))
goto Lnostage;
list_subtract(&stagelist,cs);
agi = 1; // we put out an AGI
}
}
// Look through stagelist, and insert any other conflicting instructions
for (list_t l = stagelist; l; l = ln)
{
ln = list_next(l);
Cinfo* cs = (Cinfo *)list_ptr(l);
if (conflict(cs,ci,0) && // if conflict
!(cs->flags & ci->flags & CIFLpush))
{
if (cs->spadjust)
{
// We need to insert all previous adjustments to ESP
list_t lan;
for (list_t la = stagelist; la != l; la = lan)
{
lan = list_next(la);
Cinfo* ca = (Cinfo *)list_ptr(la);
if (ca->spadjust)
{ if (!insert(ca))
goto Lnostage;
list_subtract(&stagelist,ca);
}
}
}
if (!insert(cs))
goto Lnostage;
list_subtract(&stagelist,cs);
}
}
// If floating point opcode, don't stage it, send it right out
if (!agi && ci->flags & CIFLnostage)
{
if (!insert(ci))
goto Lnostage;
return 1;
}
list_append(&stagelist,ci); // append to staging list
return 1;
Lnostage:
return 0;
}
/********************************************
* Snip off tail of instruction sequence.
* Returns:
* next instruction (the tail) or
* NULL for no more instructions
*/
STATIC code * csnip(code *c)
{
if (c)
{
unsigned iflags = c->Iflags & CFclassinit;
code **pc;
while (1)
{
pc = &code_next(c);
c = *pc;
if (!c)
break;
if (c->Iflags & (CFtarg | CFtarg2))
break;
if (!(c->Iop == NOP ||
c->Iop == (ESCAPE | ESClinnum) ||
c->Iflags & iflags))
break;
}
*pc = NULL;
}
return c;
}
/******************************
* Schedule Pentium instructions,
* based on Steve Russell's algorithm.
*/
static code *schedule(code *c,regm_t scratch)
{
code *cresult = NULL;
code **pctail = &cresult;
Schedule sch;
sch.initialize(0); // initialize scheduling table
while (c)
{
if ((c->Iop == NOP ||
((c->Iop & ESCAPEmask) == ESCAPE && c->Iop != (ESCAPE | ESCadjfpu)) ||
c->Iflags & CFclassinit) &&
!(c->Iflags & (CFtarg | CFtarg2)))
{ code *cn;
// Just append this instruction to pctail and go to the next one
*pctail = c;
cn = code_next(c);
code_next(c) = NULL;
pctail = &code_next(c);
c = cn;
continue;
}
//printf("init\n");
sch.initialize(sch.fpustackused); // initialize scheduling table
while (c)
{
//printf("insert %p\n",c);
if (!sch.stage(c)) // store c in scheduling table
break;
c = csnip(c);
}
//printf("assem %d\n",sch.tblmax);
pctail = sch.assemble(pctail); // reassemble instruction stream
}
return cresult;
}
/**************************************************************************/
/********************************************
* Replace any occurrence of r1 in EA with r2.
*/
STATIC void repEA(code *c,unsigned r1,unsigned r2)
{
unsigned mod,reg,rm;
unsigned rmn;
rmn = c->Irm;
mod = rmn & 0xC0;
reg = rmn & modregrm(0,7,0);
rm = rmn & 7;
if (mod == 0xC0 && rm == r1)
; //c->Irm = mod | reg | r2;
else if (is32bitaddr(I32,c->Iflags) &&
// If not disp32
(rmn & modregrm(3,0,7)) != modregrm(0,0,5))
{
if (rm == 4)
{ // SIB byte addressing
unsigned sib;
unsigned base;
unsigned index;
sib = c->Isib;
base = sib & 7;
index = (sib >> 3) & 7;
if (base == r1 &&
!(r1 == 5 && mod == 0) &&
!(r2 == 5 && mod == 0)
)
base = r2;
if (index == r1)
index = r2;
c->Isib = (sib & 0xC0) | (index << 3) | base;
}
else if (rm == r1)
{
if (r1 == BP && r2 == SP)
{ // Replace [EBP] with [ESP]
c->Irm = mod | reg | 4;
c->Isib = modregrm(0,4,SP);
}
else if (r2 == BP && mod == 0)
{
c->Irm = modregrm(1,0,0) | reg | r2;
c->IFL1 = FLconst;
c->IEV1.Vint = 0;
}
else
c->Irm = mod | reg | r2;
}
}
}
/******************************************
* Instruction scheduler.
* Input:
* c list of instructions to schedule
* scratch scratch registers we can use
* Returns:
* revised list of scheduled instructions
*/
/******************************************
* Swap c1 and c2.
* c1 comes before c2.
* Swap in place to not disturb addresses of jmp targets
*/
STATIC void code_swap(code *c1,code *c2)
{ code cs;
// Special case of:
// PUSH reg1
// MOV reg2,x[ESP]
//printf("code_swap(%x, %x)\n",c1,c2);
if ((c1->Iop & ~7) == 0x50 &&
c2->Iop == 0x8B &&
(c2->Irm & modregrm(3,0,7)) == modregrm(1,0,4) &&
c2->Isib == modregrm(0,4,SP) &&
c2->IFL1 == FLconst &&
((signed char)c2->IEVpointer1) >= REGSIZE &&
(c1->Iop & 7) != ((c2->Irm >> 3) & 7)
)
c2->IEVpointer1 -= REGSIZE;
cs = *c2;
*c2 = *c1;
*c1 = cs;
// Retain original CFtarg
c1->Iflags = (c1->Iflags & ~(CFtarg | CFtarg2)) | (c2->Iflags & (CFtarg | CFtarg2));
c2->Iflags = (c2->Iflags & ~(CFtarg | CFtarg2)) | (cs.Iflags & (CFtarg | CFtarg2));
c1->next = c2->next;
c2->next = cs.next;
}
code *peephole(code *cstart,regm_t scratch)
{
// Look for cases of:
// MOV r1,r2
// OP ?,r1
// we can replace with:
// MOV r1,r2
// OP ?,r2
// to improve pairing
code *c1;
unsigned r1,r2;
unsigned mod,reg,rm;
//printf("peephole\n");
for (code *c = cstart; c; c = c1)
{
unsigned char rmn;
//c->print();
c1 = cnext(c);
Ln:
if (!c1)
break;
if (c1->Iflags & (CFtarg | CFtarg2))
continue;
// Do:
// PUSH reg
if (I32 && (c->Iop & ~7) == 0x50)
{
unsigned regx = c->Iop & 7;
// MOV [ESP],regx => NOP
if (c1->Iop == 0x8B &&
c1->Irm == modregrm(0,regx,4) &&
c1->Isib == modregrm(0,4,SP))
{ c1->Iop = NOP;
continue;
}
// PUSH [ESP] => PUSH regx
if (c1->Iop == 0xFF &&
c1->Irm == modregrm(0,6,4) &&
c1->Isib == modregrm(0,4,SP))
{ c1->Iop = 0x50 + regx;
continue;
}
// CMP [ESP],imm => CMP regx,i,,
if (c1->Iop == 0x83 &&
c1->Irm == modregrm(0,7,4) &&
c1->Isib == modregrm(0,4,SP))
{ c1->Irm = modregrm(3,7,regx);
if (c1->IFL2 == FLconst && (signed char)c1->IEV2.Vuns == 0)
{ // to TEST regx,regx
c1->Iop = (c1->Iop & 1) | 0x84;
c1->Irm = modregrm(3,regx,regx);
}
continue;
}
}
// Do:
// MOV reg,[ESP] => PUSH reg
// ADD ESP,4 => NOP
if (I32 && c->Iop == 0x8B && (c->Irm & 0xC7) == modregrm(0,0,4) &&
c->Isib == modregrm(0,4,SP) &&
c1->Iop == 0x83 && (c1->Irm & 0xC7) == modregrm(3,0,SP) &&
!(c1->Iflags & CFpsw) && c1->IFL2 == FLconst && c1->IEV2.Vint == 4)
{
unsigned regx = (c->Irm >> 3) & 7;
c->Iop = 0x58 + regx;
c1->Iop = NOP;
continue;
}
// Combine two SUBs of the same register
if (c->Iop == c1->Iop &&
c->Iop == 0x83 &&
(c->Irm & 0xC0) == 0xC0 &&
(c->Irm & modregrm(3,0,7)) == (c1->Irm & modregrm(3,0,7)) &&
!(c1->Iflags & CFpsw) &&
c->IFL2 == FLconst && c1->IFL2 == FLconst
)
{ int i = (signed char)c->IEV2.Vint;
int i1 = (signed char)c1->IEV2.Vint;
switch ((c->Irm & modregrm(0,7,0)) | ((c1->Irm & modregrm(0,7,0)) >> 3))
{
case (0 << 3) | 0: // ADD, ADD
case (5 << 3) | 5: // SUB, SUB
i += i1;
goto Laa;
case (0 << 3) | 5: // ADD, SUB
case (5 << 3) | 0: // SUB, ADD
i -= i1;
goto Laa;
Laa:
if ((signed char)i != i)
c->Iop &= ~2;
c->IEV2.Vint = i;
c1->Iop = NOP;
if (i == 0)
c->Iop = NOP;
continue;
}
}
if (c->Iop == 0x8B && (c->Irm & 0xC0) == 0xC0) // MOV r1,r2
{ r1 = (c->Irm >> 3) & 7;
r2 = c->Irm & 7;
}
else if (c->Iop == 0x89 && (c->Irm & 0xC0) == 0xC0) // MOV r1,r2
{ r1 = c->Irm & 7;
r2 = (c->Irm >> 3) & 7;
}
else
{
continue;
}
rmn = c1->Irm;
mod = rmn & 0xC0;
reg = rmn & modregrm(0,7,0);
rm = rmn & 7;
if (cod3_EA(c1))
repEA(c1,r1,r2);
switch (c1->Iop)
{
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57: // PUSH reg
if ((c1->Iop & 7) == r1)
{ c1->Iop = 0x50 | r2;
//printf("schedule PUSH reg\n");
}
break;
case 0x81:
case 0x83:
// Look for CMP EA,imm
if (reg == modregrm(0,7,0))
{
if (mod == 0xC0 && rm == r1)
c1->Irm = mod | reg | r2;
}
break;
case 0x84: // TEST reg,byte ptr EA
if (r1 >= 4 || r2 >= 4) // if not a byte register
break;
if ((rmn & 0xC0) == 0xC0)
{
if ((rmn & 3) == r1)
{ c1->Irm = rmn = (rmn & modregrm(3,7,4)) | r2;
//printf("schedule 1\n");
}
}
if ((rmn & modregrm(0,3,0)) == modregrm(0,r1,0))
{ c1->Irm = (rmn & modregrm(3,4,7)) | modregrm(0,r2,0);
//printf("schedule 2\n");
}
break;
case 0x85: // TEST reg,word ptr EA
if ((rmn & 0xC0) == 0xC0)
{
if ((rmn & 7) == r1)
{ c1->Irm = rmn = (rmn & modregrm(3,7,0)) | r2;
//printf("schedule 3\n");
}
}
if ((rmn & modregrm(0,7,0)) == modregrm(0,r1,0))
{ c1->Irm = (rmn & modregrm(3,0,7)) | modregrm(0,r2,0);
//printf("schedule 4\n");
}
break;
case 0x89: // MOV EA,reg
if ((rmn & modregrm(0,7,0)) == modregrm(0,r1,0))
{ c1->Irm = (rmn & modregrm(3,0,7)) | modregrm(0,r2,0);
//printf("schedule 5\n");
if (c1->Irm == modregrm(3,r2,r2))
goto Lnop;
}
break;
case 0x8B: // MOV reg,EA
if ((rmn & 0xC0) == 0xC0 &&
(rmn & 7) == r1) // if EA == r1
{ c1->Irm = (rmn & modregrm(3,7,0)) | r2;
//printf("schedule 6\n");
if (c1->Irm == modregrm(3,r2,r2))
goto Lnop;
}
break;
case 0x3C: // CMP AL,imm8
if (r1 == AX && r2 < 4)
{ c1->Iop = 0x80;
c1->Irm = modregrm(3,7,r2);
//printf("schedule 7, r2 = %d\n", r2);
}
break;
case 0x3D: // CMP AX,imm16
if (r1 == AX)
{ c1->Iop = 0x81;
c1->Irm = modregrm(3,7,r2);
if (c1->IFL2 == FLconst &&
c1->IEV2.Vuns == (signed char)c1->IEV2.Vuns)
c1->Iop = 0x83;
//printf("schedule 8\n");
}
break;
}
continue;
Lnop:
c1->Iop = NOP;
c1 = cnext(c1);
goto Ln;
}
L1: ;
return cstart;
}
/*****************************************************************/
/**********************************************
* Replace complex instructions with simple ones more conducive
* to scheduling.
*/
code *simpleops(code *c,regm_t scratch)
{ code *cstart;
unsigned reg;
code *c2;
// Worry about using registers not saved yet by prolog
scratch &= ~fregsaved;
if (!(scratch & (scratch - 1))) // if 0 or 1 registers
return c;
reg = findreg(scratch);
cstart = c;
for (code** pc = &cstart; *pc; pc = &code_next(*pc))
{
c = *pc;
if (c->Iflags & (CFtarg | CFtarg2 | CFopsize))
continue;
if (c->Iop == 0x83 &&
(c->Irm & modregrm(0,7,0)) == modregrm(0,7,0) &&
(c->Irm & modregrm(3,0,0)) != modregrm(3,0,0)
)
{ // Replace CMP mem,imm with:
// MOV reg,mem
// CMP reg,imm
targ_long imm;
//printf("replacing CMP\n");
c->Iop = 0x8B;
c->Irm = (c->Irm & modregrm(3,0,7)) | modregrm(0,reg,0);
c2 = code_calloc();
if (reg == AX)
c2->Iop = 0x3D;
else
{ c2->Iop = 0x83;
c2->Irm = modregrm(3,7,reg);
}
c2->IFL2 = c->IFL2;
c2->IEV2 = c->IEV2;
// See if c2 should be replaced by a TEST
imm = c2->IEV2.Vuns;
if (!(c2->Iop & 1))
imm &= 0xFF;
else if (I32 ? c->Iflags & CFopsize : !(c->Iflags & CFopsize))
imm = (short) imm;
if (imm == 0)
{
c2->Iop = 0x85; // TEST reg,reg
c2->Irm = modregrm(3,reg,reg);
}
goto L1;
}
else if (c->Iop == 0xFF &&
(c->Irm & modregrm(0,7,0)) == modregrm(0,6,0) &&
(c->Irm & modregrm(3,0,0)) != modregrm(3,0,0)
)
{ // Replace PUSH mem with:
// MOV reg,mem
// PUSH reg
// printf("replacing PUSH\n");
c->Iop = 0x8B;
c->Irm = (c->Irm & modregrm(3,0,7)) | modregrm(0,reg,0);
c2 = gen1(NULL,0x50 + reg);
L1:
//c->print();
//c2->print();
c2->next = c->next;
c->next = c2;
// Switch to another reg
if (scratch & ~mask[reg])
reg = findreg(scratch & ~mask[reg]);
}
}
return cstart;
}
void Cinfo::print()
{
Cinfo *ci = this;
if (ci == NULL)
{
printf("Cinfo 0\n");
return;
}
printf("Cinfo %p: c %p, pair %x, sz %d, isz %d, flags - ",
ci,c,pair,sz,isz);
if (ci->flags & CIFLarraybounds)
printf("arraybounds,");
if (ci->flags & CIFLea)
printf("ea,");
if (ci->flags & CIFLnostage)
printf("nostage,");
if (ci->flags & CIFLpush)
printf("push,");
if (ci->flags & ~(CIFLarraybounds|CIFLnostage|CIFLpush|CIFLea))
printf("bad flag,");
printf("\n\tr %lx w %lx a %lx reg %x uops %x sibmodrm %x spadjust %ld\n",
(long)r,(long)w,(long)a,reg,uops,sibmodrm,(long)spadjust);
if (ci->fp_op)
{
static const char *fpops[] = {"fstp","fld","fop"};
printf("\tfp_op %s, fxch_pre %x, fxch_post %x\n",
fpops[fp_op-1],fxch_pre,fxch_post);
}
}
#endif
|
the_stack_data/25138004.c | /*
* Copyright 2016 The Emscripten Authors. All rights reserved.
* Emscripten is available under two separate licenses, the MIT license and the
* University of Illinois/NCSA Open Source License. Both these licenses can be
* found in the LICENSE file.
*/
#include <stdint.h>
#include <stdio.h>
int main(int argc, char** argv) {
int y = -133;
int64_t x = ((int64_t)((short)(y))) * (100 + argc);
if (x > 0)
printf(">0\n");
else
printf("<=0\n");
}
|
the_stack_data/41954.c | /*
* C Program to Find the Largest value in a Tree using
* Inorder Traversal
* 40
* /\
* 20 60
* /\ \
* 10 30 80
* \
* 90
*/
#include <stdio.h>
#include <stdlib.h>
struct btnode
{
int value;
struct btnode *left, *right;
};
typedef struct btnode node;
/* function prototypes */
void insert(node *, node *);
void inorder(node *);
void largest(node *);
void main()
{
node *root = NULL, *new = NULL ;
int num = 1;
printf("Enter the elements of the tree(enter 0 to exit)\n");
while (1)
{
scanf("%d", &num);
if (num == 0)
break;
new = malloc(sizeof(node));
new->left = new->right = NULL;
new->value = num;
if (root == NULL)
root = new;
else
{
insert(new, root);
}
}
printf("elements in a tree in inorder are\n");
inorder(root);
largest(root);
}
/* displaying nodes of a tree using inorder */
void inorder(node *root)
{
if (root != NULL)
{
inorder(root->left);
printf("%d -> ", root->value);
inorder(root->right);
}
}
/* inserting nodes into the tree */
void insert(node * new , node *root)
{
if (new->value > root->value)
{
if (root->right == NULL)
root->right = new;
else
insert (new, root->right);
}
if (new->value < root->value)
{
if (root->left == NULL)
root->left = new;
else
insert(new, root->left);
}
}
/* finding largest node in a tree */
void largest(node *root)
{
if (root->right == NULL)
{
printf("largest element is %d", root->value);
}
while (root != NULL && root->right != NULL)
{
root = root->right;
}
printf("\nlargest value is %d\n", root->value);
}
|
the_stack_data/76699091.c | #include <stdio.h>
#include <stdlib.h>
// A vertex of the graph
struct node
{
int vertex;
struct node *next;
};
// Some declarations
struct node *createNode(int v);
struct Graph
{
int numVertices;
int *visited;
struct node *
*adjLists; // we need int** to store a two dimensional array. Similary,
// we need struct node** to store an array of Linked lists
};
struct Graph *createGraph(int);
void addEdge(struct Graph *, int, int);
void printGraph(struct Graph *);
void dfs(struct Graph *, int);
int main()
{
int vertices, edges, source, i, src, dst;
printf("Enter the number of vertices\n");
scanf("%d", &vertices);
struct Graph *graph = createGraph(vertices);
printf("Enter the number of edges\n");
scanf("%d", &edges);
for (i = 0; i < edges; i++)
{
printf("Edge %d \nEnter source: ", i + 1);
scanf("%d", &src);
printf("Enter destination: ");
scanf("%d", &dst);
addEdge(graph, src, dst);
}
printf("Enter source of DFS\n");
scanf("%d", &source);
printf("DFS from %d is:\n", source);
dfs(graph, source);
printf("\n");
// Uncomment below part to get a ready-made example
/*struct Graph* graph = createGraph(4);
addEdge(graph, 0, 1);
addEdge(graph, 0, 2);
addEdge(graph, 1, 2);
addEdge(graph, 2, 3);
printf("DFS from 0 is:\n");
dfs(graph,0);
printf("\n");*/
return 0;
}
// Recursive dfs approach
void dfs(struct Graph *graph, int vertex)
{
struct node *adjList = graph->adjLists[vertex];
struct node *temp = adjList;
// Add vertex to visited list and print it
graph->visited[vertex] = 1;
printf("%d ", vertex);
// Recursively call the dfs function on all unvisited neighbours
while (temp != NULL)
{
int connectedVertex = temp->vertex;
if (graph->visited[connectedVertex] == 0)
{
dfs(graph, connectedVertex);
}
temp = temp->next;
}
}
// Allocate memory for a node
struct node *createNode(int v)
{
struct node *newNode = malloc(sizeof(struct node));
newNode->vertex = v;
newNode->next = NULL;
return newNode;
}
// Allocate memory for the entire graph structure
struct Graph *createGraph(int vertices)
{
struct Graph *graph = malloc(sizeof(struct Graph));
graph->numVertices = vertices;
graph->adjLists = malloc(vertices * sizeof(struct node *));
graph->visited = malloc(vertices * sizeof(int));
int i;
for (i = 0; i < vertices; i++)
{
graph->adjLists[i] = NULL;
graph->visited[i] = 0;
}
return graph;
}
// Creates a bidirectional graph
void addEdge(struct Graph *graph, int src, int dest)
{
// Add edge from src to dest
struct node *newNode = createNode(dest);
newNode->next = graph->adjLists[src];
graph->adjLists[src] = newNode;
// Add edge from dest to src
newNode = createNode(src);
newNode->next = graph->adjLists[dest];
graph->adjLists[dest] = newNode;
}
// Utility function to see state of graph at a given time
void printGraph(struct Graph *graph)
{
int v;
for (v = 0; v < graph->numVertices; v++)
{
struct node *temp = graph->adjLists[v];
printf("\n Adjacency list of vertex %d\n ", v);
while (temp)
{
printf("%d -> ", temp->vertex);
temp = temp->next;
}
printf("\n");
}
}
|
the_stack_data/184519113.c | /* Sed: http://msdn.microsoft.com/library/en-us/shellcc/platform/shell/programmersguide/versions.asp */
#if defined (_WIN32) && (defined(_USRDLL) || defined(DLL_EXPORT) || defined(PIC))
#include <windows.h>
#include <shlwapi.h>
#include "zintconfig.h"
#ifdef __cplusplus
extern "C"
{
#endif
__declspec(dllexport) HRESULT DllGetVersion (DLLVERSIONINFO2* pdvi);
#ifdef __cplusplus
}
#endif
HRESULT DllGetVersion (DLLVERSIONINFO2* pdvi)
{
if (!pdvi || (sizeof(*pdvi) != pdvi->info1.cbSize))
return (E_INVALIDARG);
pdvi->info1.dwMajorVersion = ZINT_VERSION_MAJOR;
pdvi->info1.dwMinorVersion = ZINT_VERSION_MINOR;
pdvi->info1.dwBuildNumber = ZINT_VERSION_RELEASE;
pdvi->info1.dwPlatformID = DLLVER_PLATFORM_WINDOWS;
if (sizeof(DLLVERSIONINFO2) == pdvi->info1.cbSize)
pdvi->ullVersion = MAKEDLLVERULL(ZINT_VERSION_MAJOR, ZINT_VERSION_MINOR, ZINT_VERSION_RELEASE, ZINT_VERSION_BUILD);
return S_OK;
}
#else
/* https://stackoverflow.com/a/26541331 Suppresses gcc warning ISO C forbids an empty translation unit */
typedef int make_iso_compilers_happy;
#endif /* _WIN32 */
|
the_stack_data/111077993.c | /*
* SquareRoot.c
*
* Created on: Mar 14, 2016
* Author:
*/
#include <math.h>
#ifndef SQUAREROOT_MOCK
double SquareRoot (double x){
return sqrt(x);
}
#endif |
the_stack_data/107269.c | int i = 21;
int j;
void increment_i()
{
i++;
}
void set_j()
{
j = 20;
}
int main(void) {
increment_i();
set_j();
return i + j;
}
|
the_stack_data/95449527.c | /*********************************************************************
* SEGGER Microcontroller GmbH *
* The Embedded Experts *
**********************************************************************
* *
* (c) 1995 - 2019 SEGGER Microcontroller GmbH *
* *
* www.segger.com Support: [email protected] *
* *
**********************************************************************
* *
* SEGGER RTT * Real Time Transfer for embedded targets *
* *
**********************************************************************
* *
* All rights reserved. *
* *
* SEGGER strongly recommends to not make any changes *
* to or modify the source code of this software in order to stay *
* compatible with the RTT protocol and J-Link. *
* *
* Redistribution and use in source and binary forms, with or *
* without modification, are permitted provided that the following *
* condition is met: *
* *
* o Redistributions of source code must retain the above copyright *
* notice, this condition and the following disclaimer. *
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
* DAMAGE. *
* *
**********************************************************************
* *
* RTT version: 6.82 *
* *
**********************************************************************
---------------------------END-OF-HEADER------------------------------
File : SEGGER_RTT_Syscalls_IAR.c
Purpose : Low-level functions for using printf() via RTT in IAR.
To use RTT for printf output, include this file in your
application and set the Library Configuration to Normal.
Revision: $Rev: 17697 $
----------------------------------------------------------------------
*/
#ifdef __IAR_SYSTEMS_ICC__
//
// Since IAR EWARM V8 and EWRX V4, yfuns.h is considered as deprecated and LowLevelIOInterface.h
// shall be used instead. To not break any compatibility with older compiler versions, we have a
// version check in here.
//
#if ((defined __ICCARM__) && (__VER__ >= 8000000)) || ((defined __ICCRX__) && (__VER__ >= 400))
#include <LowLevelIOInterface.h>
#else
#include <yfuns.h>
#endif
#include "SEGGER_RTT.h"
#pragma module_name = "?__write"
/*********************************************************************
*
* Function prototypes
*
**********************************************************************
*/
size_t __write(int handle, const unsigned char * buffer, size_t size);
/*********************************************************************
*
* Global functions
*
**********************************************************************
*/
/*********************************************************************
*
* __write()
*
* Function description
* Low-level write function.
* Standard library subroutines will use this system routine
* for output to all files, including stdout.
* Write data via RTT.
*/
size_t __write(int handle, const unsigned char * buffer, size_t size) {
(void) handle; /* Not used, avoid warning */
SEGGER_RTT_Write(0, (const char*)buffer, size);
return size;
}
/*********************************************************************
*
* __write_buffered()
*
* Function description
* Low-level write function.
* Standard library subroutines will use this system routine
* for output to all files, including stdout.
* Write data via RTT.
*/
size_t __write_buffered(int handle, const unsigned char * buffer, size_t size) {
(void) handle; /* Not used, avoid warning */
SEGGER_RTT_Write(0, (const char*)buffer, size);
return size;
}
#endif
/****** End Of File *************************************************/
|
the_stack_data/82951468.c | #include<stdio.h>
#include<stdlib.h>
#define LEN 20
struct student
{
int id;
char *name;
char *sex;
double score;
};
int main()
{
struct student stu1 = {001,"秋桐","男",95.5};
struct student stu2 = {002,"小雨","女",88.5};
struct student stu3 = {003,"秋香","女",92.5};
struct student *p1,*p2,*p3;
p1 = &stu1;
p2 = &stu2;
p3 = &stu3;
printf("ID\t Name\t Sex\t Score\n");
printf("%d\t %s\t %s\t %.1f\n",stu1.id,stu1.name,stu1.sex,stu1.score);
printf("%d\t %s\t %s\t %.1f\n",(*p2).id,(*p2).name,(*p2).sex,(*p2).score);
printf("%d\t %s\t %s\t %.1f\n",p3->id,p3->name,p3->sex,p3->score);
return 0;
}
|
the_stack_data/145454402.c | #include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
#include <pwd.h>
#include <string.h>
#include <stdbool.h>
bool hidden_files_flag;
struct stat file_stat;
/*
Should use stat readdir closedir getopt
*/
/* Ivo's sample code:
// 1. opendir, readdir, closedir
// 2. stat (problems: relative/absolute paths - opendir .., string concat
// memory!!)
// getpwuid() / getgrgid()
// localtime() and tm (tm struct - CAREFUL!!)
// filter hidden dirs
// myls -> different block size (x2)
// getopt for arguments
//man 2 stat
// get pass for id func in docs
// get group id
// local time the year is 1900 and months are 11 and many more shit
// getopt(3)
int main() {
DIR *dir = opendir(".");
struct dirent *entry;
while ((entry = readdir(dir)) != NULL) {
printf("%s\n", entry->d_name);
}
closedir(dir);
struct stat st;
stat("a.out", &st); // TODO: check result of stat!!
printf("%d\n", st.st_size);
struct passwd *pwd = getpwuid(st.st_uid);
printf("%s\n", pwd->pw_name);
printf("%u\n", st.st_mtime);
struct tm *modified = localtime(&st.st_mtime);
printf("%d\n", modified->tm_min);
}
*/
void print_file_type(int mode){
if(S_ISREG(mode)){
printf("-");
}
if(S_ISDIR(mode)){
printf("d");
}
if(S_ISCHR(mode)){
printf("b");
}
if(S_ISBLK(mode)){
printf("c");
}
if(S_ISFIFO(mode)){
printf("p");
}
if(S_ISLNK(mode)){
printf("l");
}
if(S_ISSOCK(mode)){
printf("s");
}
}
int main(int argc, char **argv){
int opt;
while ((opt = getopt(argc, argv, "a")) != -1){
switch(opt){
case 'a':
hidden_files_flag = true;
break;
default:
printf("No such option as %c", opt);
break;
}
}
DIR *dir = opendir(".");
struct dirent *entry;
while ((entry = readdir(dir)) != NULL) {
printf("%s\n", entry->d_name);
}
stat("./", &file_stat);
printf("%d\n", file_stat.st_size);
printf("%d\n", file_stat.st_uid);
print_file_type(file_stat.st_mode);
struct passwd *pwd = getpwuid(file_stat.st_uid);
printf("%d\n", pwd->pw_name);
printf("%d\n", file_stat.st_mtime);
return 0;
}
|
the_stack_data/29316.c | #include <stdio.h>
#include <omp.h>
void funcA() {
printf("En funcA: esta sección la ejecuta el thread %d\n",
omp_get_thread_num());
}
void funcB() {
printf("En funcB: esta sección la ejecuta el thread %d\n",
omp_get_thread_num());
}
int main(int argc, char ** argv) {
#pragma omp parallel sections
{
#pragma omp section
(void) funcA();
#pragma omp section
(void) funcB();
}
return(0);
}
|
the_stack_data/14199091.c | #include <stdint.h>
#include <stdlib.h>
#include <string.h>
__asm__(".symver memcpy,memcpy@GLIBC_2.2.5");
#ifdef __cplusplus
extern "C" {
#endif
extern void *__wrap_memcpy(void *dest,const void *src,size_t n)
{
return memcpy(dest,src,n);
}
#ifdef __cplusplus
}
#endif
|
the_stack_data/64341.c | // https://www.codechef.com/MAY20B/problems/COVID19
#include <stdio.h>
int main()
{
int t;
scanf("%d",&t);
while(t-->0){
int n;
scanf("%d",&n);
int pos[n];
for(int i=0;i<n;i++)
scanf("%d",&pos[i]);
int m0=0;
int m1=1;
int prs=1;
for(int i=0;i<n-1;i++){
if(pos[i+1]-pos[i]<=2){
prs++;
}
else{
m1=(m1>prs)?m1:prs;
if(!m0){
m0=m1;
}
else{
m0=(m0<prs)?m0:prs;
}
prs=1;
}
}
m1=(m1>prs)?m1:prs;
if(!m0){
m0=m1;
}
else{
m0=(m0<prs)?m0:prs;
}
printf("%d %d\n",m0,m1);
}
return 0;
}
|
the_stack_data/70449128.c | #include <stdio.h>
#include <string.h>
int main(){
int i=0;
char name1[10];
char name2[10];
printf("Enter the two names:\n");
gets(name1);
gets(name2);
while(name1[i]==name2[i] && name1[i]!='\0' && name2[i]!='\0')
{
i++;
}
if(name1[i]!='\0' && name2[i]!='\0')
printf("The names are equal\n");
else
printf("The names are not equal\n");
return 0;
}
|
the_stack_data/43407.c | #define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char DataType;
typedef struct
{
DataType data;
char lChild;
char rChild;
}PTree;
void CreatPTree(PTree *);
void Print(PTree *);
int main()
{
PTree tree;
CreatPTree(&tree);
Print(&tree);
getchar();
getchar();
return 0;
}
void CreatPTree(PTree * T)
{
DataType ch;
scanf("%c", &ch);
if (ch=='#')
{
T = NULL;
}
else
{
T = (PTree *)malloc(sizeof(PTree));
if (!T)
{
exit(1);
}
else
{
T->data = ch;
CreatPTree(&T->lChild);
CreatPTree(&T->rChild);
}
}
}
void Print(PTree * T)
{
if (T == NULL)
{
return;
}
else
{
Print(T->lChild);
Print(T->rChild);
}
}
|
the_stack_data/645535.c | #include<stdio.h>
long long jiecheng(int);
int main()
{int m,n;
scanf("%d%d",&m,&n);
printf("%d",jiecheng(m)/jiecheng(m-n)/jiecheng(n));
return 0;
}
long long jiecheng(int a)
{long long sum=1;
for (int i=1;i<=a;i++)
{sum=sum*i;
}
return sum;
} |
the_stack_data/84607.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
float con(float);
int main()
{
float t;
printf("Enter temperature in celcius: ");
scanf("%f",&t);
printf("\nThe fahrenheit equivalance of this temperature is: %.2f.\n",con(t));
return 0;
}
float con(float t)
{
return ((9.0*t/5.0)+32.0);
}
|
the_stack_data/72012690.c | // REQUIRES: arm-registered-target
// RUN: %clang_cc1 -no-opaque-pointers -triple armv7-apple-darwin9 -emit-llvm -w -o - %s | FileCheck %s
void clear(void *ptr, void *ptr2) {
// CHECK: clear
// CHECK: load i8*, i8**
// CHECK: load i8*, i8**
__clear_cache(ptr, ptr2);
}
|
the_stack_data/1142969.c | #include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct student
{
char name[26];
char sem[1];
char branch[10];
char roll_no[7];
struct student* next;
}*head=NULL;
void create()
{
int n,i;
struct student* temp,*newnode;
printf("Enter the number of students you want to enter\n");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
newnode=(struct student*)malloc(sizeof(struct student));
printf("Enter the name of student %d:",i);
scanf("%s",newnode->name);
printf("Enter the semester of student %d:",i);
fflush(stdin);
scanf("%s",newnode->sem);
printf("Enter the branch of student %d:",i);
fflush(stdin);
scanf("%s",newnode->branch);
printf("Enter the roll number of student %d:",i);
fflush(stdin);
scanf("%s",newnode->roll_no);
if(head==NULL)
{
head=(struct student*)malloc(sizeof(struct student));
head=newnode;
head->next=NULL;
temp=head;
}
else{
newnode->next=NULL;
temp->next=newnode;
temp=temp->next;
}
}
}
void traverse()
{
int i=1;
struct student* temp;
temp=head;
if(head==NULL)
{
printf("The list was empty\n");
}
while(temp!=NULL)
{
printf("\nthe student%d \n1.Name:%s\n2.Roll No:%s\n3.Semester:%s\n4.Branch:%s\n",i,temp->name,temp->roll_no,temp->sem,temp->branch);
temp=temp->next;
i++;
}
}
void insert()
{
int i;
int position;
struct student* temp, *ptr;
struct student* newnode;
printf("Enter the position where you want to insert\n");
scanf("%d",&position);
newnode=(struct student*)malloc(sizeof(struct student));
printf("Enter the name of student");
scanf("%s",newnode->name);
printf("Enter the semester of student");
scanf("%s",newnode->sem);
printf("Enter the branch of student");
scanf("%s",newnode->branch);
printf("Enter the roll number of student");
scanf("%s",newnode->roll_no);
if(position==1)
{
newnode->next=head;
head=newnode;
}
if(position>1)
{
temp=head;
for(i=1;i<position-1;i++)
{
if(temp==NULL)
{
printf("The given element does not exist\n");
exit(1);
}
else
{
temp=temp->next;
}
}
ptr=head;
for(i=1;i<=position-1;i++)
{
ptr=ptr->next;
}
newnode->next=NULL;
temp->next=newnode;
temp=temp->next;
temp->next=ptr;
}
}
void deletion()
{
char rollno[7];
struct student* temp, *prev;
printf("Enter the roll no u want to delete\n");
scanf("%s",&rollno);
temp=head;
prev=head;
while(temp!=NULL)
{
if(strcmp(rollno,temp->roll_no)==0&&temp==head)
{
head=head->next;
free(temp);
break;
}
else
{
temp=temp->next;
if(strcmp(rollno,temp->roll_no)==0)
{
prev->next=temp->next;
temp->next=NULL;
free(temp);
break;
}
prev=prev->next;
}
}
}
void search()
{
char rollno[7];
int flag=0,count=1;
struct student* temp;
printf("Enter the roll no you want to search\n");
scanf("%s",&rollno);
temp=head;
while(temp!=NULL)
{
if(strcmp(rollno,temp->roll_no)==0)
{
printf("the element found at position %d\n",count);
flag++;
break;
}
temp=temp->next;
count++;
}
if(flag==0)
{
printf("element not found\n");
}
}
void count()
{
struct student* temp;
int count=0;
temp=head;
if(temp==NULL)
{
printf("The list is empty\n");
}
else{
while(temp!=NULL)
{
temp=temp->next;
count++;
}
printf("%d\n",count);
}
}
void update()
{
struct student* temp;
char rollno[7];
int flag;
temp=head;
printf("Enter the roll no you want to update\n");
scanf("%s",rollno);
while(temp!=NULL)
{
if(strcmp(rollno,temp->roll_no)==0)
{
printf("Enter the name of student");
scanf("%s",temp->name);
printf("Enter the semester of student");
scanf("%s",temp->sem);
printf("Enter the branch of student");
scanf("%s",temp->branch);
printf("Enter the roll number of student");
scanf("%s",temp->roll_no);
flag++;
break;
}
temp=temp->next;
}
if(flag==0)
{
printf("roll number not found\n");
}
}
int main()
{
int choice;
do{
printf("\n1.Create\n");
printf("2.Display\n");
printf("3.Insert\n");
printf("4.Delete\n");
printf("5.Search\n");
printf("6.Count the nodes present\n");
printf("7.Update\n");
printf("8.Exit\n");
printf("Enter the choice you want to enter\n");
scanf("%d",&choice);
switch(choice)
{
case 1:
create();
continue;
case 2:
traverse();
continue;
case 3:
insert();
continue;
case 4:
deletion();
continue;
case 5:
search();
continue;
case 6:
count();
continue;
case 7:
update();
continue;
default:
printf("Enter a valid choice");
continue;
}}while(choice!=8);
return 0;
}
|
the_stack_data/1005790.c | extern float __VERIFIER_nondet_float(void);
extern int __VERIFIER_nondet_int(void);
typedef enum {false, true} bool;
bool __VERIFIER_nondet_bool(void) {
return __VERIFIER_nondet_int() != 0;
}
int main()
{
bool _EL_X_845, _x__EL_X_845;
bool _EL_U_852, _x__EL_U_852;
float x_12, _x_x_12;
float x_3, _x_x_3;
float x_1, _x_x_1;
float x_9, _x_x_9;
float x_14, _x_x_14;
float x_0, _x_x_0;
float x_15, _x_x_15;
float x_2, _x_x_2;
float x_4, _x_x_4;
float x_6, _x_x_6;
float x_7, _x_x_7;
float x_8, _x_x_8;
float x_5, _x_x_5;
float x_10, _x_x_10;
float x_11, _x_x_11;
bool _EL_X_843, _x__EL_X_843;
float x_13, _x_x_13;
int __steps_to_fair = __VERIFIER_nondet_int();
_EL_X_845 = __VERIFIER_nondet_bool();
_EL_U_852 = __VERIFIER_nondet_bool();
x_12 = __VERIFIER_nondet_float();
x_3 = __VERIFIER_nondet_float();
x_1 = __VERIFIER_nondet_float();
x_9 = __VERIFIER_nondet_float();
x_14 = __VERIFIER_nondet_float();
x_0 = __VERIFIER_nondet_float();
x_15 = __VERIFIER_nondet_float();
x_2 = __VERIFIER_nondet_float();
x_4 = __VERIFIER_nondet_float();
x_6 = __VERIFIER_nondet_float();
x_7 = __VERIFIER_nondet_float();
x_8 = __VERIFIER_nondet_float();
x_5 = __VERIFIER_nondet_float();
x_10 = __VERIFIER_nondet_float();
x_11 = __VERIFIER_nondet_float();
_EL_X_843 = __VERIFIER_nondet_bool();
x_13 = __VERIFIER_nondet_float();
bool __ok = (1 && ( !(((x_3 + (-1.0 * x_12)) <= -20.0) || (_EL_U_852 && ( !_EL_X_845)))));
while (__steps_to_fair >= 0 && __ok) {
if ((((x_3 + (-1.0 * x_12)) <= -20.0) || ( !(((x_3 + (-1.0 * x_12)) <= -20.0) || (_EL_U_852 && ( !_EL_X_845)))))) {
__steps_to_fair = __VERIFIER_nondet_int();
} else {
__steps_to_fair--;
}
_x__EL_X_845 = __VERIFIER_nondet_bool();
_x__EL_U_852 = __VERIFIER_nondet_bool();
_x_x_12 = __VERIFIER_nondet_float();
_x_x_3 = __VERIFIER_nondet_float();
_x_x_1 = __VERIFIER_nondet_float();
_x_x_9 = __VERIFIER_nondet_float();
_x_x_14 = __VERIFIER_nondet_float();
_x_x_0 = __VERIFIER_nondet_float();
_x_x_15 = __VERIFIER_nondet_float();
_x_x_2 = __VERIFIER_nondet_float();
_x_x_4 = __VERIFIER_nondet_float();
_x_x_6 = __VERIFIER_nondet_float();
_x_x_7 = __VERIFIER_nondet_float();
_x_x_8 = __VERIFIER_nondet_float();
_x_x_5 = __VERIFIER_nondet_float();
_x_x_10 = __VERIFIER_nondet_float();
_x_x_11 = __VERIFIER_nondet_float();
_x__EL_X_843 = __VERIFIER_nondet_bool();
_x_x_13 = __VERIFIER_nondet_float();
__ok = ((((((((((((((((((((x_15 + (-1.0 * _x_x_0)) <= -18.0) && (((x_13 + (-1.0 * _x_x_0)) <= -10.0) && (((x_12 + (-1.0 * _x_x_0)) <= -20.0) && (((x_10 + (-1.0 * _x_x_0)) <= -15.0) && (((x_6 + (-1.0 * _x_x_0)) <= -8.0) && (((x_3 + (-1.0 * _x_x_0)) <= -20.0) && (((x_1 + (-1.0 * _x_x_0)) <= -11.0) && ((x_2 + (-1.0 * _x_x_0)) <= -11.0)))))))) && (((x_15 + (-1.0 * _x_x_0)) == -18.0) || (((x_13 + (-1.0 * _x_x_0)) == -10.0) || (((x_12 + (-1.0 * _x_x_0)) == -20.0) || (((x_10 + (-1.0 * _x_x_0)) == -15.0) || (((x_6 + (-1.0 * _x_x_0)) == -8.0) || (((x_3 + (-1.0 * _x_x_0)) == -20.0) || (((x_1 + (-1.0 * _x_x_0)) == -11.0) || ((x_2 + (-1.0 * _x_x_0)) == -11.0))))))))) && ((((x_11 + (-1.0 * _x_x_1)) <= -9.0) && (((x_10 + (-1.0 * _x_x_1)) <= -7.0) && (((x_9 + (-1.0 * _x_x_1)) <= -4.0) && (((x_6 + (-1.0 * _x_x_1)) <= -18.0) && (((x_4 + (-1.0 * _x_x_1)) <= -16.0) && (((x_2 + (-1.0 * _x_x_1)) <= -11.0) && (((x_0 + (-1.0 * _x_x_1)) <= -2.0) && ((x_1 + (-1.0 * _x_x_1)) <= -13.0)))))))) && (((x_11 + (-1.0 * _x_x_1)) == -9.0) || (((x_10 + (-1.0 * _x_x_1)) == -7.0) || (((x_9 + (-1.0 * _x_x_1)) == -4.0) || (((x_6 + (-1.0 * _x_x_1)) == -18.0) || (((x_4 + (-1.0 * _x_x_1)) == -16.0) || (((x_2 + (-1.0 * _x_x_1)) == -11.0) || (((x_0 + (-1.0 * _x_x_1)) == -2.0) || ((x_1 + (-1.0 * _x_x_1)) == -13.0)))))))))) && ((((x_15 + (-1.0 * _x_x_2)) <= -17.0) && (((x_14 + (-1.0 * _x_x_2)) <= -19.0) && (((x_11 + (-1.0 * _x_x_2)) <= -12.0) && (((x_8 + (-1.0 * _x_x_2)) <= -1.0) && (((x_7 + (-1.0 * _x_x_2)) <= -12.0) && (((x_5 + (-1.0 * _x_x_2)) <= -17.0) && (((x_1 + (-1.0 * _x_x_2)) <= -13.0) && ((x_2 + (-1.0 * _x_x_2)) <= -15.0)))))))) && (((x_15 + (-1.0 * _x_x_2)) == -17.0) || (((x_14 + (-1.0 * _x_x_2)) == -19.0) || (((x_11 + (-1.0 * _x_x_2)) == -12.0) || (((x_8 + (-1.0 * _x_x_2)) == -1.0) || (((x_7 + (-1.0 * _x_x_2)) == -12.0) || (((x_5 + (-1.0 * _x_x_2)) == -17.0) || (((x_1 + (-1.0 * _x_x_2)) == -13.0) || ((x_2 + (-1.0 * _x_x_2)) == -15.0)))))))))) && ((((x_15 + (-1.0 * _x_x_3)) <= -8.0) && (((x_13 + (-1.0 * _x_x_3)) <= -17.0) && (((x_11 + (-1.0 * _x_x_3)) <= -13.0) && (((x_8 + (-1.0 * _x_x_3)) <= -1.0) && (((x_5 + (-1.0 * _x_x_3)) <= -10.0) && (((x_3 + (-1.0 * _x_x_3)) <= -10.0) && (((x_1 + (-1.0 * _x_x_3)) <= -5.0) && ((x_2 + (-1.0 * _x_x_3)) <= -11.0)))))))) && (((x_15 + (-1.0 * _x_x_3)) == -8.0) || (((x_13 + (-1.0 * _x_x_3)) == -17.0) || (((x_11 + (-1.0 * _x_x_3)) == -13.0) || (((x_8 + (-1.0 * _x_x_3)) == -1.0) || (((x_5 + (-1.0 * _x_x_3)) == -10.0) || (((x_3 + (-1.0 * _x_x_3)) == -10.0) || (((x_1 + (-1.0 * _x_x_3)) == -5.0) || ((x_2 + (-1.0 * _x_x_3)) == -11.0)))))))))) && ((((x_13 + (-1.0 * _x_x_4)) <= -17.0) && (((x_12 + (-1.0 * _x_x_4)) <= -1.0) && (((x_9 + (-1.0 * _x_x_4)) <= -10.0) && (((x_8 + (-1.0 * _x_x_4)) <= -16.0) && (((x_7 + (-1.0 * _x_x_4)) <= -5.0) && (((x_4 + (-1.0 * _x_x_4)) <= -4.0) && (((x_0 + (-1.0 * _x_x_4)) <= -2.0) && ((x_2 + (-1.0 * _x_x_4)) <= -13.0)))))))) && (((x_13 + (-1.0 * _x_x_4)) == -17.0) || (((x_12 + (-1.0 * _x_x_4)) == -1.0) || (((x_9 + (-1.0 * _x_x_4)) == -10.0) || (((x_8 + (-1.0 * _x_x_4)) == -16.0) || (((x_7 + (-1.0 * _x_x_4)) == -5.0) || (((x_4 + (-1.0 * _x_x_4)) == -4.0) || (((x_0 + (-1.0 * _x_x_4)) == -2.0) || ((x_2 + (-1.0 * _x_x_4)) == -13.0)))))))))) && ((((x_14 + (-1.0 * _x_x_5)) <= -18.0) && (((x_13 + (-1.0 * _x_x_5)) <= -5.0) && (((x_11 + (-1.0 * _x_x_5)) <= -6.0) && (((x_9 + (-1.0 * _x_x_5)) <= -5.0) && (((x_6 + (-1.0 * _x_x_5)) <= -1.0) && (((x_4 + (-1.0 * _x_x_5)) <= -1.0) && (((x_0 + (-1.0 * _x_x_5)) <= -7.0) && ((x_1 + (-1.0 * _x_x_5)) <= -4.0)))))))) && (((x_14 + (-1.0 * _x_x_5)) == -18.0) || (((x_13 + (-1.0 * _x_x_5)) == -5.0) || (((x_11 + (-1.0 * _x_x_5)) == -6.0) || (((x_9 + (-1.0 * _x_x_5)) == -5.0) || (((x_6 + (-1.0 * _x_x_5)) == -1.0) || (((x_4 + (-1.0 * _x_x_5)) == -1.0) || (((x_0 + (-1.0 * _x_x_5)) == -7.0) || ((x_1 + (-1.0 * _x_x_5)) == -4.0)))))))))) && ((((x_12 + (-1.0 * _x_x_6)) <= -3.0) && (((x_10 + (-1.0 * _x_x_6)) <= -12.0) && (((x_8 + (-1.0 * _x_x_6)) <= -15.0) && (((x_7 + (-1.0 * _x_x_6)) <= -3.0) && (((x_6 + (-1.0 * _x_x_6)) <= -7.0) && (((x_5 + (-1.0 * _x_x_6)) <= -2.0) && (((x_1 + (-1.0 * _x_x_6)) <= -6.0) && ((x_2 + (-1.0 * _x_x_6)) <= -11.0)))))))) && (((x_12 + (-1.0 * _x_x_6)) == -3.0) || (((x_10 + (-1.0 * _x_x_6)) == -12.0) || (((x_8 + (-1.0 * _x_x_6)) == -15.0) || (((x_7 + (-1.0 * _x_x_6)) == -3.0) || (((x_6 + (-1.0 * _x_x_6)) == -7.0) || (((x_5 + (-1.0 * _x_x_6)) == -2.0) || (((x_1 + (-1.0 * _x_x_6)) == -6.0) || ((x_2 + (-1.0 * _x_x_6)) == -11.0)))))))))) && ((((x_14 + (-1.0 * _x_x_7)) <= -1.0) && (((x_12 + (-1.0 * _x_x_7)) <= -14.0) && (((x_10 + (-1.0 * _x_x_7)) <= -13.0) && (((x_9 + (-1.0 * _x_x_7)) <= -7.0) && (((x_8 + (-1.0 * _x_x_7)) <= -1.0) && (((x_6 + (-1.0 * _x_x_7)) <= -4.0) && (((x_3 + (-1.0 * _x_x_7)) <= -8.0) && ((x_5 + (-1.0 * _x_x_7)) <= -5.0)))))))) && (((x_14 + (-1.0 * _x_x_7)) == -1.0) || (((x_12 + (-1.0 * _x_x_7)) == -14.0) || (((x_10 + (-1.0 * _x_x_7)) == -13.0) || (((x_9 + (-1.0 * _x_x_7)) == -7.0) || (((x_8 + (-1.0 * _x_x_7)) == -1.0) || (((x_6 + (-1.0 * _x_x_7)) == -4.0) || (((x_3 + (-1.0 * _x_x_7)) == -8.0) || ((x_5 + (-1.0 * _x_x_7)) == -5.0)))))))))) && ((((x_9 + (-1.0 * _x_x_8)) <= -12.0) && (((x_8 + (-1.0 * _x_x_8)) <= -19.0) && (((x_7 + (-1.0 * _x_x_8)) <= -14.0) && (((x_5 + (-1.0 * _x_x_8)) <= -10.0) && (((x_4 + (-1.0 * _x_x_8)) <= -2.0) && (((x_2 + (-1.0 * _x_x_8)) <= -18.0) && (((x_0 + (-1.0 * _x_x_8)) <= -14.0) && ((x_1 + (-1.0 * _x_x_8)) <= -7.0)))))))) && (((x_9 + (-1.0 * _x_x_8)) == -12.0) || (((x_8 + (-1.0 * _x_x_8)) == -19.0) || (((x_7 + (-1.0 * _x_x_8)) == -14.0) || (((x_5 + (-1.0 * _x_x_8)) == -10.0) || (((x_4 + (-1.0 * _x_x_8)) == -2.0) || (((x_2 + (-1.0 * _x_x_8)) == -18.0) || (((x_0 + (-1.0 * _x_x_8)) == -14.0) || ((x_1 + (-1.0 * _x_x_8)) == -7.0)))))))))) && ((((x_15 + (-1.0 * _x_x_9)) <= -18.0) && (((x_13 + (-1.0 * _x_x_9)) <= -13.0) && (((x_12 + (-1.0 * _x_x_9)) <= -7.0) && (((x_10 + (-1.0 * _x_x_9)) <= -5.0) && (((x_6 + (-1.0 * _x_x_9)) <= -13.0) && (((x_5 + (-1.0 * _x_x_9)) <= -7.0) && (((x_1 + (-1.0 * _x_x_9)) <= -8.0) && ((x_3 + (-1.0 * _x_x_9)) <= -20.0)))))))) && (((x_15 + (-1.0 * _x_x_9)) == -18.0) || (((x_13 + (-1.0 * _x_x_9)) == -13.0) || (((x_12 + (-1.0 * _x_x_9)) == -7.0) || (((x_10 + (-1.0 * _x_x_9)) == -5.0) || (((x_6 + (-1.0 * _x_x_9)) == -13.0) || (((x_5 + (-1.0 * _x_x_9)) == -7.0) || (((x_1 + (-1.0 * _x_x_9)) == -8.0) || ((x_3 + (-1.0 * _x_x_9)) == -20.0)))))))))) && ((((x_15 + (-1.0 * _x_x_10)) <= -14.0) && (((x_12 + (-1.0 * _x_x_10)) <= -9.0) && (((x_10 + (-1.0 * _x_x_10)) <= -18.0) && (((x_9 + (-1.0 * _x_x_10)) <= -6.0) && (((x_8 + (-1.0 * _x_x_10)) <= -11.0) && (((x_6 + (-1.0 * _x_x_10)) <= -2.0) && (((x_1 + (-1.0 * _x_x_10)) <= -11.0) && ((x_4 + (-1.0 * _x_x_10)) <= -20.0)))))))) && (((x_15 + (-1.0 * _x_x_10)) == -14.0) || (((x_12 + (-1.0 * _x_x_10)) == -9.0) || (((x_10 + (-1.0 * _x_x_10)) == -18.0) || (((x_9 + (-1.0 * _x_x_10)) == -6.0) || (((x_8 + (-1.0 * _x_x_10)) == -11.0) || (((x_6 + (-1.0 * _x_x_10)) == -2.0) || (((x_1 + (-1.0 * _x_x_10)) == -11.0) || ((x_4 + (-1.0 * _x_x_10)) == -20.0)))))))))) && ((((x_15 + (-1.0 * _x_x_11)) <= -13.0) && (((x_13 + (-1.0 * _x_x_11)) <= -10.0) && (((x_10 + (-1.0 * _x_x_11)) <= -3.0) && (((x_8 + (-1.0 * _x_x_11)) <= -3.0) && (((x_6 + (-1.0 * _x_x_11)) <= -19.0) && (((x_4 + (-1.0 * _x_x_11)) <= -4.0) && (((x_1 + (-1.0 * _x_x_11)) <= -11.0) && ((x_2 + (-1.0 * _x_x_11)) <= -7.0)))))))) && (((x_15 + (-1.0 * _x_x_11)) == -13.0) || (((x_13 + (-1.0 * _x_x_11)) == -10.0) || (((x_10 + (-1.0 * _x_x_11)) == -3.0) || (((x_8 + (-1.0 * _x_x_11)) == -3.0) || (((x_6 + (-1.0 * _x_x_11)) == -19.0) || (((x_4 + (-1.0 * _x_x_11)) == -4.0) || (((x_1 + (-1.0 * _x_x_11)) == -11.0) || ((x_2 + (-1.0 * _x_x_11)) == -7.0)))))))))) && ((((x_14 + (-1.0 * _x_x_12)) <= -20.0) && (((x_13 + (-1.0 * _x_x_12)) <= -1.0) && (((x_10 + (-1.0 * _x_x_12)) <= -15.0) && (((x_8 + (-1.0 * _x_x_12)) <= -5.0) && (((x_4 + (-1.0 * _x_x_12)) <= -20.0) && (((x_2 + (-1.0 * _x_x_12)) <= -7.0) && (((x_0 + (-1.0 * _x_x_12)) <= -18.0) && ((x_1 + (-1.0 * _x_x_12)) <= -7.0)))))))) && (((x_14 + (-1.0 * _x_x_12)) == -20.0) || (((x_13 + (-1.0 * _x_x_12)) == -1.0) || (((x_10 + (-1.0 * _x_x_12)) == -15.0) || (((x_8 + (-1.0 * _x_x_12)) == -5.0) || (((x_4 + (-1.0 * _x_x_12)) == -20.0) || (((x_2 + (-1.0 * _x_x_12)) == -7.0) || (((x_0 + (-1.0 * _x_x_12)) == -18.0) || ((x_1 + (-1.0 * _x_x_12)) == -7.0)))))))))) && ((((x_15 + (-1.0 * _x_x_13)) <= -7.0) && (((x_14 + (-1.0 * _x_x_13)) <= -19.0) && (((x_12 + (-1.0 * _x_x_13)) <= -19.0) && (((x_11 + (-1.0 * _x_x_13)) <= -7.0) && (((x_10 + (-1.0 * _x_x_13)) <= -7.0) && (((x_6 + (-1.0 * _x_x_13)) <= -3.0) && (((x_2 + (-1.0 * _x_x_13)) <= -8.0) && ((x_5 + (-1.0 * _x_x_13)) <= -8.0)))))))) && (((x_15 + (-1.0 * _x_x_13)) == -7.0) || (((x_14 + (-1.0 * _x_x_13)) == -19.0) || (((x_12 + (-1.0 * _x_x_13)) == -19.0) || (((x_11 + (-1.0 * _x_x_13)) == -7.0) || (((x_10 + (-1.0 * _x_x_13)) == -7.0) || (((x_6 + (-1.0 * _x_x_13)) == -3.0) || (((x_2 + (-1.0 * _x_x_13)) == -8.0) || ((x_5 + (-1.0 * _x_x_13)) == -8.0)))))))))) && ((((x_13 + (-1.0 * _x_x_14)) <= -10.0) && (((x_11 + (-1.0 * _x_x_14)) <= -16.0) && (((x_10 + (-1.0 * _x_x_14)) <= -4.0) && (((x_8 + (-1.0 * _x_x_14)) <= -6.0) && (((x_5 + (-1.0 * _x_x_14)) <= -17.0) && (((x_4 + (-1.0 * _x_x_14)) <= -6.0) && (((x_2 + (-1.0 * _x_x_14)) <= -20.0) && ((x_3 + (-1.0 * _x_x_14)) <= -10.0)))))))) && (((x_13 + (-1.0 * _x_x_14)) == -10.0) || (((x_11 + (-1.0 * _x_x_14)) == -16.0) || (((x_10 + (-1.0 * _x_x_14)) == -4.0) || (((x_8 + (-1.0 * _x_x_14)) == -6.0) || (((x_5 + (-1.0 * _x_x_14)) == -17.0) || (((x_4 + (-1.0 * _x_x_14)) == -6.0) || (((x_2 + (-1.0 * _x_x_14)) == -20.0) || ((x_3 + (-1.0 * _x_x_14)) == -10.0)))))))))) && ((((x_12 + (-1.0 * _x_x_15)) <= -10.0) && (((x_8 + (-1.0 * _x_x_15)) <= -20.0) && (((x_7 + (-1.0 * _x_x_15)) <= -3.0) && (((x_6 + (-1.0 * _x_x_15)) <= -15.0) && (((x_4 + (-1.0 * _x_x_15)) <= -4.0) && (((x_2 + (-1.0 * _x_x_15)) <= -14.0) && (((x_0 + (-1.0 * _x_x_15)) <= -6.0) && ((x_1 + (-1.0 * _x_x_15)) <= -18.0)))))))) && (((x_12 + (-1.0 * _x_x_15)) == -10.0) || (((x_8 + (-1.0 * _x_x_15)) == -20.0) || (((x_7 + (-1.0 * _x_x_15)) == -3.0) || (((x_6 + (-1.0 * _x_x_15)) == -15.0) || (((x_4 + (-1.0 * _x_x_15)) == -4.0) || (((x_2 + (-1.0 * _x_x_15)) == -14.0) || (((x_0 + (-1.0 * _x_x_15)) == -6.0) || ((x_1 + (-1.0 * _x_x_15)) == -18.0)))))))))) && ((_EL_U_852 == ((_x__EL_U_852 && ( !_x__EL_X_845)) || ((_x_x_3 + (-1.0 * _x_x_12)) <= -20.0))) && ((_EL_X_843 == (6.0 <= (_x_x_4 + (-1.0 * _x_x_7)))) && (_EL_X_845 == _x__EL_X_843))));
_EL_X_845 = _x__EL_X_845;
_EL_U_852 = _x__EL_U_852;
x_12 = _x_x_12;
x_3 = _x_x_3;
x_1 = _x_x_1;
x_9 = _x_x_9;
x_14 = _x_x_14;
x_0 = _x_x_0;
x_15 = _x_x_15;
x_2 = _x_x_2;
x_4 = _x_x_4;
x_6 = _x_x_6;
x_7 = _x_x_7;
x_8 = _x_x_8;
x_5 = _x_x_5;
x_10 = _x_x_10;
x_11 = _x_x_11;
_EL_X_843 = _x__EL_X_843;
x_13 = _x_x_13;
}
}
|
the_stack_data/155372.c | // compile
// gcc 2-functions.c -o 2-functions -fno-stack-protector
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
void win()
{
printf("Congratulations, you win!!! You successfully changed the code flow\n");
}
int main(int argc, char **argv)
{
int (*fp)();
char buffer[64];
fp = 0;
printf("You win this game if you are able to call the function win.'\n");
gets(buffer);
if(fp) {
printf("calling function pointer, jumping to %p\n", fp);
fp();
}
} |
the_stack_data/72013518.c | #include <stdio.h>
#define SPACE 50
int main(void) {
char name[SPACE];
char * ptr;
// Header
printf("Assignment #0-1, kingofthenorth, [email protected]\n\n");
// Program (Using fgets method)
printf("What is your name?\n");
ptr = fgets(name, SPACE, stdin);
printf("Hello %s!", ptr);
return 0;
}
|
the_stack_data/193894347.c | // RUN: %clang_cc1 -triple i386-apple-darwin10 -analyze -analyzer-config eagerly-assume=false -analyzer-checker=core.uninitialized.Assign,debug.ExprInspection -verify %s
void clang_analyzer_eval(int);
void initbug(void) {
const union { float a; } u = {};
(void)u.a; // no-crash
}
int const parr[2] = {1};
void constarr(void) {
int i = 2;
clang_analyzer_eval(parr[i]); // expected-warning{{UNDEFINED}}
i = 1;
clang_analyzer_eval(parr[i] == 0); // expected-warning{{TRUE}}
i = -1;
clang_analyzer_eval(parr[i]); // expected-warning{{UNDEFINED}}
}
struct SM {
int a;
int b;
};
const struct SM sm = {.a = 1};
void multinit(void) {
clang_analyzer_eval(sm.a == 1); // expected-warning{{TRUE}}
clang_analyzer_eval(sm.b == 0); // expected-warning{{TRUE}}
}
const int glob_arr1[6] = {[2] = 3, [0] = 1, [1] = 2, [3] = 4};
void glob_array_index1(void) {
clang_analyzer_eval(glob_arr1[0] == 1); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr1[1] == 2); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr1[2] == 3); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr1[3] == 4); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr1[4] == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr1[5] == 0); // expected-warning{{TRUE}}
}
void glob_array_index2(void) {
const int *ptr = glob_arr1;
clang_analyzer_eval(ptr[0] == 1); // expected-warning{{TRUE}}
clang_analyzer_eval(ptr[1] == 2); // expected-warning{{TRUE}}
clang_analyzer_eval(ptr[2] == 3); // expected-warning{{TRUE}}
clang_analyzer_eval(ptr[3] == 4); // expected-warning{{TRUE}}
clang_analyzer_eval(ptr[4] == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(ptr[5] == 0); // expected-warning{{TRUE}}
}
void glob_invalid_index1(void) {
int x = -42;
int res = glob_arr1[x]; // expected-warning{{garbage or undefined}}
}
void glob_invalid_index2(void) {
const int *ptr = glob_arr1;
int x = 42;
int res = ptr[x]; // expected-warning{{garbage or undefined}}
}
const int glob_arr2[3][3] = {[0][0] = 1, [1][1] = 5, [2][0] = 7};
void glob_arr_index3(void) {
clang_analyzer_eval(glob_arr2[0][0] == 1); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr2[0][1] == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr2[0][2] == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr2[1][0] == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr2[1][1] == 5); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr2[1][2] == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr2[2][0] == 7); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr2[2][1] == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr2[2][2] == 0); // expected-warning{{TRUE}}
}
void negative_index(void) {
int x = 2, y = -2;
clang_analyzer_eval(glob_arr2[x][y] == 5); // expected-warning{{UNDEFINED}}
x = 3;
y = -3;
clang_analyzer_eval(glob_arr2[x][y] == 7); // expected-warning{{UNDEFINED}}
}
void glob_invalid_index3(void) {
int x = -1, y = -1;
int res = glob_arr2[x][y]; // expected-warning{{garbage or undefined}}
}
void glob_invalid_index4(void) {
int x = 3, y = 2;
int res = glob_arr2[x][y]; // expected-warning{{garbage or undefined}}
}
const int glob_arr_no_init[10];
void glob_arr_index4(void) {
// FIXME: Should warn {{FALSE}}, since the array has a static storage.
clang_analyzer_eval(glob_arr_no_init[2]); // expected-warning{{UNKNOWN}}
}
const int glob_arr3[]; // IncompleteArrayType
const int glob_arr3[4] = {1, 2, 3}; // ConstantArrayType
void glob_arr_index5(void) {
clang_analyzer_eval(glob_arr3[0] == 1); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr3[1] == 2); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr3[2] == 3); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr3[3] == 0); // expected-warning{{TRUE}}
}
void glob_invalid_index5(void) {
int x = 42;
int res = glob_arr3[x]; // expected-warning{{garbage or undefined}}
}
void glob_invalid_index6(void) {
int x = -42;
int res = glob_arr3[x]; // expected-warning{{garbage or undefined}}
}
const int glob_arr4[]; // IncompleteArrayType
const int glob_arr4[4] = {1, 2, 3}; // ConstantArrayType
const int glob_arr4[]; // ConstantArrayType (according to AST)
void glob_arr_index6(void) {
clang_analyzer_eval(glob_arr4[0] == 1); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr4[1] == 2); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr4[2] == 3); // expected-warning{{TRUE}}
clang_analyzer_eval(glob_arr4[3] == 0); // expected-warning{{TRUE}}
}
void glob_invalid_index7(void) {
int x = 42;
int res = glob_arr4[x]; // expected-warning{{garbage or undefined}}
}
void glob_invalid_index8(void) {
int x = -42;
int res = glob_arr4[x]; // expected-warning{{garbage or undefined}}
}
|
the_stack_data/11457.c | /* @Author: Kishan Adhikari
@Filename: enter.c
@Created Date: 2078/05/10
@Description:Write characters into a file “filec.txt”. The set of characters are read from the keyboard until
an enter key is pressed (use putc() and getc() function).
*/
#include <stdio.h> //linking section
#include <stdlib.h>
//main function
int main()
{
char ch;
FILE *fptr;
fptr = fopen("filec.txt", "w+");
if (fptr == NULL)
{
printf("Error opening file");
exit(0);
}
printf("Enter text to enter\n");
while ((ch = getchar()) != '\n')
{
putc(ch, fptr);
}
fclose(fptr);
printf("Text on file is\n");
fptr = fopen("filec.txt", "r");
while ((ch = getc(fptr)) != EOF)
{ // reading each character from file
printf("%c", ch); // displaying each character on to the screen
}
printf("\n");
fclose(fptr);
return 0;
}
|
the_stack_data/36311.c | /****************************************************************************/
/* lldiv.c */
/* */
/* Copyright (c) 2002 Texas Instruments Incorporated */
/* http://www.ti.com/ */
/* */
/* Redistribution and use in source and binary forms, with or without */
/* modification, are permitted provided that the following conditions */
/* are met: */
/* */
/* Redistributions of source code must retain the above copyright */
/* notice, this list of conditions and the following disclaimer. */
/* */
/* Redistributions in binary form must reproduce the above copyright */
/* notice, this list of conditions and the following disclaimer in */
/* the documentation and/or other materials provided with the */
/* distribution. */
/* */
/* Neither the name of Texas Instruments Incorporated nor the names */
/* of its contributors may be used to endorse or promote products */
/* derived from this software without specific prior written */
/* permission. */
/* */
/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */
/* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */
/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */
/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */
/* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */
/* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */
/* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */
/* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */
/* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
/* */
/****************************************************************************/
#include <stdlib.h>
#include <limits.h>
lldiv_t lldiv(long long num, long long den)
{
lldiv_t rv;
rv.quot = num / den;
rv.rem = num % den;
return rv;
}
|
the_stack_data/922609.c | #include <stdio.h>
int main()
{
int arr1[25], i,n;
printf("\n\n Pointer : Store and retrieve elements from an array :\n");
printf(" Input the number of elements to store in the array :");
scanf("%d",&n);
printf(" Input %d number of elements in the array :\n",n);
for(i=0;i<n;i++)
{
printf(" element - %d : ",i);
scanf("%d",arr1+i);
}
printf(" The elements you entered are : \n");
for(i=0;i<n;i++)
{
printf(" element - %d : %d \n",i,*(arr1+i));
}
return 0;
}
|
the_stack_data/72011900.c | // This is a personal academic project. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
#ifdef BUDDY
#include <mm.h>
#include <naiveConsole.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#define MAX_LEVELS 21
#define BLOCKS_PER_LEVEL(level) (1l << (level))
#define SIZE_OF_BLOCKS_AT_LEVEL(level, total_size) \
((total_size) / (1l << (level)))
#define INDEX_OF_POINTER_IN_LEVEL(pointer, level, memory_start, total_size) \
(((pointer) - (memory_start)) / \
(SIZE_OF_BLOCKS_AT_LEVEL(level, total_size)))
uint8_t *mem_start = (uint8_t *)HEAP_START;
typedef struct _list_t *list_t;
typedef struct _list_t {
list_t prev, next;
uint8_t level;
} _list_t;
_list_t free_lists[MAX_LEVELS];
static void list_init(list_t list);
static int list_is_empty(list_t list);
static list_t list_pop(list_t list);
static void list_push(list_t list, list_t entry);
static void list_remove(list_t entry);
static int get_level(size_t size);
static list_t list_find(uint64_t addr, uint8_t level);
static uint64_t list_level_print(uint8_t level);
void heap_init()
{
list_t link;
for (int i = 0; i < MAX_LEVELS; i++) {
list_init(&free_lists[i]);
}
link = (list_t)mem_start;
list_init(link);
list_push(&free_lists[0], link);
}
void *alloc(size_t size)
{
int level = get_level(size + sizeof(_list_t));
if (level == -1)
return NULL;
void *memory;
list_t link;
int actualLevel = level;
while (actualLevel >= 0) {
if (!list_is_empty(&free_lists[actualLevel]))
break;
actualLevel--;
}
if (actualLevel == -1) // no memory
return NULL;
void *node;
for (; actualLevel < level; actualLevel++) {
node = (void *)list_pop(&free_lists[actualLevel]);
uint64_t blockSize = SIZE_OF_BLOCKS_AT_LEVEL(actualLevel + 1,
TOTAL_HEAP_SIZE);
void *left = node;
void *right = (uint8_t *)node + blockSize;
list_init(left);
list_init(right);
list_push(&free_lists[actualLevel + 1], left);
list_push(&free_lists[actualLevel + 1], right);
}
link = list_pop(&free_lists[level]);
link->level = level;
memory = link;
memory = (uint8_t *)memory + sizeof(_list_t);
return (void *)memory;
}
void free(void *address)
{
if (address == NULL)
return;
address = (uint8_t *)address - sizeof(_list_t);
list_t link = (list_t)address, buddy_link;
uint8_t level = link->level;
char stop = 0;
do {
link = (list_t)address;
size_t size = SIZE_OF_BLOCKS_AT_LEVEL(level, TOTAL_HEAP_SIZE);
uint8_t idx =
INDEX_OF_POINTER_IN_LEVEL((uint64_t)address, level,
(uint64_t)mem_start,
TOTAL_HEAP_SIZE);
uint64_t buddy;
if ((idx & 1) == 0) {
buddy = (uint64_t)address + size;
} else {
buddy = (uint64_t)address - size;
}
buddy_link = NULL;
if (!list_is_empty(&free_lists[level]))
buddy_link = list_find(buddy, level);
list_init(link);
list_push(&free_lists[level], link);
if ((uint64_t)buddy_link == buddy) {
list_remove(link);
list_remove(buddy_link);
if ((idx & 1) == 0)
address = link;
else
address = buddy_link;
} else {
stop = 1;
}
level--;
} while (!stop);
}
static void list_init(list_t list)
{
list->next = NULL;
list->prev = NULL;
}
static int list_is_empty(list_t list)
{
return list->next == NULL;
}
static list_t list_pop(list_t list)
{
list_t actual = list;
while (actual->next != NULL) {
actual = actual->next;
}
list_remove(actual);
return actual;
}
static void list_push(list_t list, list_t entry)
{
list_t actual = list;
while (actual->next != NULL) {
actual = actual->next;
}
actual->next = entry;
entry->next = NULL;
entry->prev = actual;
}
static void list_remove(list_t entry)
{
list_t prev = entry->prev;
list_t next = entry->next;
if (prev != NULL)
prev->next = next;
if (next != NULL)
next->prev = prev;
}
static list_t list_find(uint64_t addr, uint8_t level)
{
list_t aux = &free_lists[level];
aux = aux->next;
while (aux != NULL) {
if ((uint64_t)aux == addr) {
return aux;
}
aux = aux->next;
}
return NULL;
}
static uint64_t list_level_print(uint8_t level)
{
uint64_t totalMem = 0;
list_t it = &free_lists[level];
uint8_t actual = 0;
size_t size = SIZE_OF_BLOCKS_AT_LEVEL(level, TOTAL_HEAP_SIZE);
it = it->next;
while (it != NULL) {
actual++;
it = it->next;
}
totalMem = size * actual;
ncPrintDec(actual);
ncPrint(" blocks of ");
ncPrintHex(size);
ncPrint("h Bytes");
ncNewline();
return totalMem;
}
static int get_level(size_t size)
{
int level = 0;
uint64_t currSize = TOTAL_HEAP_SIZE;
if (size > currSize)
return -1;
while (size <= currSize / 2 && level < MAX_LEVELS - 1) {
level++;
currSize /= 2;
}
return level;
}
void dump_mem()
{
size_t totalMem = 0;
ncPrint("----- Dummy Memory Dump -----");
ncNewline();
ncPrint("Total Heap Size: ");
ncPrintHex(TOTAL_HEAP_SIZE);
ncPrintChar('h');
ncNewline();
for (uint8_t i = 0; i < MAX_LEVELS; i++) {
if (!list_is_empty(&free_lists[i])) {
ncPrint("Level ");
ncPrintDec(i);
ncPrint(": ");
totalMem += list_level_print(i);
}
}
ncPrint("Total Free Memory: ");
ncPrintHex(totalMem);
ncPrint("h Bytes");
ncNewline();
ncPrint("-----------------------------");
ncNewline();
}
#endif |
the_stack_data/242331730.c | /*
* mkg3_main.c -- passes fake arguments into main
*/
#undef main
int
main()
{
static char *argv[4] = {
"mkg3states", "-c", "const", "tif_fax3sm.c" };
return tool_main(4,argv); // Call the tool "main()" routine
}
|
the_stack_data/751814.c | #include<stdio.h>
int main()
{
long long int b;
scanf("%lld", &b);
printf("%lld", b/2520);
return 0;
}
|
the_stack_data/140765113.c | // Preprocessor directive
// header file <stdio.h>
#include <stdio.h>
// main is function name
// void - functions return type
void main()
{
// called function
printf("Hello\n");
}
|
the_stack_data/617565.c | #define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
extern char** environ;
__attribute__ ((__constructor__)) void preload (void)
{
// get command line options and arg
const char* cmdline = getenv("EVIL_CMDLINE");
// unset environment variable LD_PRELOAD.
// unsetenv("LD_PRELOAD") no effect on some
// distribution (e.g., centos), I need crafty trick.
int i;
for (i = 0; environ[i]; ++i) {
if (strstr(environ[i], "LD_PRELOAD")) {
environ[i][0] = '\0';
}
}
// executive command
system(cmdline);
}
|
the_stack_data/6854.c | #include <stdint.h>
#include <stdio.h>
uint64_t deinterleave(uint64_t x) {
x = x & 0x5555555555555555;
x = (x | (x >> 1)) & 0x3333333333333333;
x = (x | (x >> 2)) & 0x0f0f0f0f0f0f0f0f;
x = (x | (x >> 4)) & 0x00ff00ff00ff00ff;
x = (x | (x >> 8)) & 0x0000ffff0000ffff;
x = (x | (x >> 16)) & 0x00000000ffffffff;
return x;
}
uint64_t hilbert(uint64_t x) {
/* make `inversion mark` (lower bit) and `+2 mark` (upper bit) */
uint64_t lo = x & 0x5555555555555555;
uint64_t hi = x & 0xaaaaaaaaaaaaaaaa;
uint64_t marks = (lo ^ hi >> 1) | (hi & lo << 1);
/* cummulative xor the marks to the right */
marks ^= (marks & 0xcccccccccccccccc) >> 2;
marks ^= (marks & 0x3030303030303030) >> 4;
marks ^= (marks & 0x0300030003000300) >> 8;
marks ^= (marks & 0x0003000000030000) >> 16;
marks ^= (marks & 0x0000000300000000) >> 32;
marks ^= (marks & 0x0000000300000000) >> 16;
marks ^= (marks & 0x0003000300030000) >> 8;
marks ^= (marks & 0x0303030303030300) >> 4;
marks ^= (marks & 0x3333333333333330) >> 2;
/* flip the 2's */
x ^= marks & 0xaaaaaaaaaaaaaaaa;
/* convert to U curve */
x ^= (x & 0xaaaaaaaaaaaaaaaa) >> 1;
/* flip even coords (this is merged with the other flipping below) */
/*x = x & 0x3333333333333333 | (((x & 0x4444444444444444) << 1) |
((x & 0x8888888888888888) >> 1));*/
/* flip the coords where the lower bit in mark is set, also all even coords */
uint64_t fmask = 0x4444444444444444 ^ (marks & 0x5555555555555555);
fmask |= fmask << 1;
x = (x & ~fmask) | (fmask & (((x & 0x5555555555555555) << 1) |
((x & 0xaaaaaaaaaaaaaaaa) >> 1)));
return x;
}
int main(int argc, char **argv) {
int T = 4;
if (argc == 2)
sscanf(argv[1], "%d", &T);
if (T > 63)
T = 63;
for (uint64_t i = 0; i < (1 << T); ++i)
printf("%ld\t%ld\t%ld\t%ld\n", i, hilbert(i), deinterleave(hilbert(i)),
deinterleave(hilbert(i) >> 1));
return 0;
}
|
the_stack_data/923581.c | /*************************************************************************
> File Name: gethostbyname.c
> Author: AnSwEr
> Mail:
> Created Time: 2015年07月16日 星期四 21时34分06秒
************************************************************************/
/*
* 根据域名获取ip地址
*/
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<netdb.h>
int main(int argc,const char *argv[])
{
int i;
struct hostent *host;
char str[16];
if(argc < 2)
{
printf("Usage: %s <hostname>\n",argv[0]);
exit(1);
}
host=gethostbyname(argv[1]);
for(i = 0;host->h_addr_list[i];i++)
{
if(inet_ntop(AF_INET,host->h_addr_list[i],str,sizeof(str)) != NULL)
{
printf("IP addr %d : %s \n",i+1,str);
}
}
return 0;
}
|
the_stack_data/37099.c | #include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#define PORT 31337
int main()
{
char buf[256];
struct sockaddr_in sock_addr;
sock_addr.sin_family = AF_INET;
sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
sock_addr.sin_port = htons(PORT);
int listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
bind(listen_sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
while(1)
{
listen(listen_sock, SOMAXCONN);
int data_sock = accept(listen_sock, NULL, NULL);
while(1)
{
read(data_sock, buf, sizeof(buf));
buf[sizeof(buf) - 1] = '\0';
printf("%s\n", buf);
write(data_sock, buf, strlen(buf));
}
close(data_sock);
}
return 0;
}
|
the_stack_data/159516032.c | // WARNING in __queue_work
// https://syzkaller.appspot.com/bug?id=62843f3219094a2a5585afdf72aa9101023e8e88
// status:fixed
// autogenerated by syzkaller (http://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <endian.h>
#include <errno.h>
#include <linux/futex.h>
#include <linux/net.h>
#include <netinet/in.h>
#include <pthread.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/prctl.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
__attribute__((noreturn)) static void doexit(int status)
{
volatile unsigned i;
syscall(__NR_exit_group, status);
for (i = 0;; i++) {
}
}
#include <stdint.h>
#include <string.h>
const int kFailStatus = 67;
const int kRetryStatus = 69;
static void fail(const char* msg, ...)
{
int e = errno;
va_list args;
va_start(args, msg);
vfprintf(stderr, msg, args);
va_end(args);
fprintf(stderr, " (errno %d)\n", e);
doexit((e == ENOMEM || e == EAGAIN) ? kRetryStatus : kFailStatus);
}
static uint64_t current_time_ms()
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
fail("clock_gettime failed");
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
#define XT_TABLE_SIZE 1536
#define XT_MAX_ENTRIES 10
struct xt_counters {
uint64_t pcnt, bcnt;
};
struct ipt_getinfo {
char name[32];
unsigned int valid_hooks;
unsigned int hook_entry[5];
unsigned int underflow[5];
unsigned int num_entries;
unsigned int size;
};
struct ipt_get_entries {
char name[32];
unsigned int size;
void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};
struct ipt_replace {
char name[32];
unsigned int valid_hooks;
unsigned int num_entries;
unsigned int size;
unsigned int hook_entry[5];
unsigned int underflow[5];
unsigned int num_counters;
struct xt_counters* counters;
char entrytable[XT_TABLE_SIZE];
};
struct ipt_table_desc {
const char* name;
struct ipt_getinfo info;
struct ipt_replace replace;
};
static struct ipt_table_desc ipv4_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "mangle"},
{.name = "raw"}, {.name = "security"},
};
static struct ipt_table_desc ipv6_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "mangle"},
{.name = "raw"}, {.name = "security"},
};
#define IPT_BASE_CTL 64
#define IPT_SO_SET_REPLACE (IPT_BASE_CTL)
#define IPT_SO_GET_INFO (IPT_BASE_CTL)
#define IPT_SO_GET_ENTRIES (IPT_BASE_CTL + 1)
struct arpt_getinfo {
char name[32];
unsigned int valid_hooks;
unsigned int hook_entry[3];
unsigned int underflow[3];
unsigned int num_entries;
unsigned int size;
};
struct arpt_get_entries {
char name[32];
unsigned int size;
void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};
struct arpt_replace {
char name[32];
unsigned int valid_hooks;
unsigned int num_entries;
unsigned int size;
unsigned int hook_entry[3];
unsigned int underflow[3];
unsigned int num_counters;
struct xt_counters* counters;
char entrytable[XT_TABLE_SIZE];
};
struct arpt_table_desc {
const char* name;
struct arpt_getinfo info;
struct arpt_replace replace;
};
static struct arpt_table_desc arpt_tables[] = {
{.name = "filter"},
};
#define ARPT_BASE_CTL 96
#define ARPT_SO_SET_REPLACE (ARPT_BASE_CTL)
#define ARPT_SO_GET_INFO (ARPT_BASE_CTL)
#define ARPT_SO_GET_ENTRIES (ARPT_BASE_CTL + 1)
static void checkpoint_iptables(struct ipt_table_desc* tables, int num_tables,
int family, int level)
{
struct ipt_get_entries entries;
socklen_t optlen;
int fd, i;
fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1)
fail("socket(%d, SOCK_STREAM, IPPROTO_TCP)", family);
for (i = 0; i < num_tables; i++) {
struct ipt_table_desc* table = &tables[i];
strcpy(table->info.name, table->name);
strcpy(table->replace.name, table->name);
optlen = sizeof(table->info);
if (getsockopt(fd, level, IPT_SO_GET_INFO, &table->info, &optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
fail("getsockopt(IPT_SO_GET_INFO)");
}
if (table->info.size > sizeof(table->replace.entrytable))
fail("table size is too large: %u", table->info.size);
if (table->info.num_entries > XT_MAX_ENTRIES)
fail("too many counters: %u", table->info.num_entries);
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
fail("getsockopt(IPT_SO_GET_ENTRIES)");
table->replace.valid_hooks = table->info.valid_hooks;
table->replace.num_entries = table->info.num_entries;
table->replace.size = table->info.size;
memcpy(table->replace.hook_entry, table->info.hook_entry,
sizeof(table->replace.hook_entry));
memcpy(table->replace.underflow, table->info.underflow,
sizeof(table->replace.underflow));
memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
}
close(fd);
}
static void reset_iptables(struct ipt_table_desc* tables, int num_tables,
int family, int level)
{
struct xt_counters counters[XT_MAX_ENTRIES];
struct ipt_get_entries entries;
struct ipt_getinfo info;
socklen_t optlen;
int fd, i;
fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1)
fail("socket(%d, SOCK_STREAM, IPPROTO_TCP)", family);
for (i = 0; i < num_tables; i++) {
struct ipt_table_desc* table = &tables[i];
if (table->info.valid_hooks == 0)
continue;
memset(&info, 0, sizeof(info));
strcpy(info.name, table->name);
optlen = sizeof(info);
if (getsockopt(fd, level, IPT_SO_GET_INFO, &info, &optlen))
fail("getsockopt(IPT_SO_GET_INFO)");
if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
fail("getsockopt(IPT_SO_GET_ENTRIES)");
if (memcmp(table->replace.entrytable, entries.entrytable,
table->info.size) == 0)
continue;
}
table->replace.num_counters = info.num_entries;
table->replace.counters = counters;
optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
table->replace.size;
if (setsockopt(fd, level, IPT_SO_SET_REPLACE, &table->replace, optlen))
fail("setsockopt(IPT_SO_SET_REPLACE)");
}
close(fd);
}
static void checkpoint_arptables(void)
{
struct arpt_get_entries entries;
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1)
fail("socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)");
for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
struct arpt_table_desc* table = &arpt_tables[i];
strcpy(table->info.name, table->name);
strcpy(table->replace.name, table->name);
optlen = sizeof(table->info);
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &table->info, &optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
fail("getsockopt(ARPT_SO_GET_INFO)");
}
if (table->info.size > sizeof(table->replace.entrytable))
fail("table size is too large: %u", table->info.size);
if (table->info.num_entries > XT_MAX_ENTRIES)
fail("too many counters: %u", table->info.num_entries);
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
fail("getsockopt(ARPT_SO_GET_ENTRIES)");
table->replace.valid_hooks = table->info.valid_hooks;
table->replace.num_entries = table->info.num_entries;
table->replace.size = table->info.size;
memcpy(table->replace.hook_entry, table->info.hook_entry,
sizeof(table->replace.hook_entry));
memcpy(table->replace.underflow, table->info.underflow,
sizeof(table->replace.underflow));
memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
}
close(fd);
}
static void reset_arptables()
{
struct xt_counters counters[XT_MAX_ENTRIES];
struct arpt_get_entries entries;
struct arpt_getinfo info;
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1)
fail("socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)");
for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
struct arpt_table_desc* table = &arpt_tables[i];
if (table->info.valid_hooks == 0)
continue;
memset(&info, 0, sizeof(info));
strcpy(info.name, table->name);
optlen = sizeof(info);
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &info, &optlen))
fail("getsockopt(ARPT_SO_GET_INFO)");
if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
fail("getsockopt(ARPT_SO_GET_ENTRIES)");
if (memcmp(table->replace.entrytable, entries.entrytable,
table->info.size) == 0)
continue;
}
table->replace.num_counters = info.num_entries;
table->replace.counters = counters;
optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
table->replace.size;
if (setsockopt(fd, SOL_IP, ARPT_SO_SET_REPLACE, &table->replace, optlen))
fail("setsockopt(ARPT_SO_SET_REPLACE)");
}
close(fd);
}
static void checkpoint_net_namespace(void)
{
checkpoint_arptables();
checkpoint_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
AF_INET, SOL_IP);
checkpoint_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
AF_INET6, SOL_IPV6);
}
static void reset_net_namespace(void)
{
reset_arptables();
reset_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
AF_INET, SOL_IP);
reset_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
AF_INET6, SOL_IPV6);
}
static void test();
void loop()
{
int iter;
checkpoint_net_namespace();
for (iter = 0;; iter++) {
int pid = fork();
if (pid < 0)
fail("loop fork failed");
if (pid == 0) {
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
test();
doexit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
int res = waitpid(-1, &status, __WALL | WNOHANG);
if (res == pid)
break;
usleep(1000);
if (current_time_ms() - start > 5 * 1000) {
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
while (waitpid(-1, &status, __WALL) != pid) {
}
break;
}
}
reset_net_namespace();
}
}
struct thread_t {
int created, running, call;
pthread_t th;
};
static struct thread_t threads[16];
static void execute_call(int call);
static int running;
static void* thr(void* arg)
{
struct thread_t* th = (struct thread_t*)arg;
for (;;) {
while (!__atomic_load_n(&th->running, __ATOMIC_ACQUIRE))
syscall(SYS_futex, &th->running, FUTEX_WAIT, 0, 0);
execute_call(th->call);
__atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED);
__atomic_store_n(&th->running, 0, __ATOMIC_RELEASE);
syscall(SYS_futex, &th->running, FUTEX_WAKE);
}
return 0;
}
static void execute(int num_calls)
{
int call, thread;
running = 0;
for (call = 0; call < num_calls; call++) {
for (thread = 0; thread < sizeof(threads) / sizeof(threads[0]); thread++) {
struct thread_t* th = &threads[thread];
if (!th->created) {
th->created = 1;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 128 << 10);
pthread_create(&th->th, &attr, thr, th);
}
if (!__atomic_load_n(&th->running, __ATOMIC_ACQUIRE)) {
th->call = call;
__atomic_fetch_add(&running, 1, __ATOMIC_RELAXED);
__atomic_store_n(&th->running, 1, __ATOMIC_RELEASE);
syscall(SYS_futex, &th->running, FUTEX_WAKE);
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 20 * 1000 * 1000;
syscall(SYS_futex, &th->running, FUTEX_WAIT, 1, &ts);
if (running)
usleep((call == num_calls - 1) ? 10000 : 1000);
break;
}
}
}
}
long r[1];
void execute_call(int call)
{
switch (call) {
case 0:
syscall(__NR_mmap, 0x20000000, 0xfff000, 3, 0x32, -1, 0);
break;
case 1:
r[0] = syscall(__NR_socket, 0xa, 2, 0);
break;
case 2:
memcpy((void*)0x20103ba0, "\x73\x65\x63\x75\x72\x69\x74\x79\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00",
32);
*(uint32_t*)0x20103bc0 = 0xe;
*(uint32_t*)0x20103bc4 = 4;
*(uint32_t*)0x20103bc8 = 0x400;
*(uint32_t*)0x20103bcc = -1;
*(uint32_t*)0x20103bd0 = 0;
*(uint32_t*)0x20103bd4 = 0;
*(uint32_t*)0x20103bd8 = 0x260;
*(uint32_t*)0x20103bdc = -1;
*(uint32_t*)0x20103be0 = -1;
*(uint32_t*)0x20103be4 = 0x330;
*(uint32_t*)0x20103be8 = 0x330;
*(uint32_t*)0x20103bec = 0x330;
*(uint32_t*)0x20103bf0 = -1;
*(uint32_t*)0x20103bf4 = 4;
*(uint64_t*)0x20103bf8 = 0x20bf8fc0;
*(uint8_t*)0x20103c00 = 0xfe;
*(uint8_t*)0x20103c01 = 0x80;
*(uint8_t*)0x20103c02 = 0;
*(uint8_t*)0x20103c03 = 0;
*(uint8_t*)0x20103c04 = 0;
*(uint8_t*)0x20103c05 = 0;
*(uint8_t*)0x20103c06 = 0;
*(uint8_t*)0x20103c07 = 0;
*(uint8_t*)0x20103c08 = 0;
*(uint8_t*)0x20103c09 = 0;
*(uint8_t*)0x20103c0a = 0;
*(uint8_t*)0x20103c0b = 0;
*(uint8_t*)0x20103c0c = 0;
*(uint8_t*)0x20103c0d = 0;
*(uint8_t*)0x20103c0e = 0;
*(uint8_t*)0x20103c0f = 0xbb;
*(uint8_t*)0x20103c10 = 0;
*(uint8_t*)0x20103c11 = 0;
*(uint8_t*)0x20103c12 = 0;
*(uint8_t*)0x20103c13 = 0;
*(uint8_t*)0x20103c14 = 0;
*(uint8_t*)0x20103c15 = 0;
*(uint8_t*)0x20103c16 = 0;
*(uint8_t*)0x20103c17 = 0;
*(uint8_t*)0x20103c18 = 0;
*(uint8_t*)0x20103c19 = 0;
*(uint8_t*)0x20103c1a = -1;
*(uint8_t*)0x20103c1b = -1;
*(uint32_t*)0x20103c1c = htobe32(-1);
*(uint32_t*)0x20103c20 = htobe32(0xffffff00);
*(uint32_t*)0x20103c24 = htobe32(0xff000000);
*(uint32_t*)0x20103c28 = htobe32(0);
*(uint32_t*)0x20103c2c = htobe32(0xff);
*(uint32_t*)0x20103c30 = htobe32(0xff);
*(uint32_t*)0x20103c34 = htobe32(0xffffff00);
*(uint32_t*)0x20103c38 = htobe32(0);
*(uint32_t*)0x20103c3c = htobe32(-1);
memcpy((void*)0x20103c40,
"\x74\x64\x2b\x13\xb5\x72\x2e\x37\x64\x74\xc1\x04\xcc\xe4\x92\x42",
16);
memcpy((void*)0x20103c50,
"\x8f\xd4\xba\x00\x2b\x0f\x5d\x06\xd7\x1c\xe4\xc1\x9b\x0d\xca\xac",
16);
*(uint8_t*)0x20103c60 = -1;
*(uint8_t*)0x20103c61 = 0;
*(uint8_t*)0x20103c62 = 0;
*(uint8_t*)0x20103c63 = 0;
*(uint8_t*)0x20103c64 = 0;
*(uint8_t*)0x20103c65 = 0;
*(uint8_t*)0x20103c66 = 0;
*(uint8_t*)0x20103c67 = 0;
*(uint8_t*)0x20103c68 = 0;
*(uint8_t*)0x20103c69 = 0;
*(uint8_t*)0x20103c6a = 0;
*(uint8_t*)0x20103c6b = 0;
*(uint8_t*)0x20103c6c = 0;
*(uint8_t*)0x20103c6d = 0;
*(uint8_t*)0x20103c6e = 0;
*(uint8_t*)0x20103c6f = 0;
*(uint8_t*)0x20103c70 = 0;
*(uint8_t*)0x20103c71 = 0;
*(uint8_t*)0x20103c72 = 0;
*(uint8_t*)0x20103c73 = 0;
*(uint8_t*)0x20103c74 = 0;
*(uint8_t*)0x20103c75 = 0;
*(uint8_t*)0x20103c76 = 0;
*(uint8_t*)0x20103c77 = 0;
*(uint8_t*)0x20103c78 = 0;
*(uint8_t*)0x20103c79 = 0;
*(uint8_t*)0x20103c7a = 0;
*(uint8_t*)0x20103c7b = 0;
*(uint8_t*)0x20103c7c = 0;
*(uint8_t*)0x20103c7d = 0;
*(uint8_t*)0x20103c7e = 0;
*(uint8_t*)0x20103c7f = 0;
*(uint16_t*)0x20103c80 = 0x7f;
*(uint8_t*)0x20103c82 = 7;
*(uint8_t*)0x20103c83 = 7;
*(uint8_t*)0x20103c84 = 8;
*(uint32_t*)0x20103c88 = 0;
*(uint16_t*)0x20103c8c = 0xf0;
*(uint16_t*)0x20103c8e = 0x138;
*(uint32_t*)0x20103c90 = 0;
*(uint64_t*)0x20103c98 = 0;
*(uint64_t*)0x20103ca0 = 0;
*(uint16_t*)0x20103ca8 = 0x48;
memcpy((void*)0x20103caa, "\x68\x62\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00",
29);
*(uint8_t*)0x20103cc7 = 0;
*(uint32_t*)0x20103cc8 = 7;
*(uint8_t*)0x20103ccc = 2;
*(uint8_t*)0x20103ccd = 1;
*(uint16_t*)0x20103cce = 3;
*(uint16_t*)0x20103cd0 = 0x800;
*(uint16_t*)0x20103cd2 = 4;
*(uint16_t*)0x20103cd4 = 0;
*(uint16_t*)0x20103cd6 = 5;
*(uint16_t*)0x20103cd8 = 0x101;
*(uint16_t*)0x20103cda = 0x100;
*(uint16_t*)0x20103cdc = 4;
*(uint16_t*)0x20103cde = 0x800;
*(uint16_t*)0x20103ce0 = 0xd50f;
*(uint16_t*)0x20103ce2 = 5;
*(uint16_t*)0x20103ce4 = 0xfffc;
*(uint16_t*)0x20103ce6 = 0x52f0;
*(uint16_t*)0x20103ce8 = 4;
*(uint16_t*)0x20103cea = 0x8000;
*(uint16_t*)0x20103cec = 0x100;
*(uint8_t*)0x20103cee = 8;
*(uint16_t*)0x20103cf0 = 0x48;
memcpy((void*)0x20103cf2, "\x49\x44\x4c\x45\x54\x49\x4d\x45\x52\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00",
29);
*(uint8_t*)0x20103d0f = 0;
*(uint32_t*)0x20103d10 = 0x80000000;
memcpy((void*)0x20103d14, "\x73\x79\x7a\x30\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00",
28);
*(uint64_t*)0x20103d30 = 0x80000001;
*(uint8_t*)0x20103d38 = -1;
*(uint8_t*)0x20103d39 = 1;
*(uint8_t*)0x20103d3a = 0;
*(uint8_t*)0x20103d3b = 0;
*(uint8_t*)0x20103d3c = 0;
*(uint8_t*)0x20103d3d = 0;
*(uint8_t*)0x20103d3e = 0;
*(uint8_t*)0x20103d3f = 0;
*(uint8_t*)0x20103d40 = 0;
*(uint8_t*)0x20103d41 = 0;
*(uint8_t*)0x20103d42 = 0;
*(uint8_t*)0x20103d43 = 0;
*(uint8_t*)0x20103d44 = 0;
*(uint8_t*)0x20103d45 = 0;
*(uint8_t*)0x20103d46 = 0;
*(uint8_t*)0x20103d47 = 1;
*(uint8_t*)0x20103d48 = 0xfe;
*(uint8_t*)0x20103d49 = 0x80;
*(uint8_t*)0x20103d4a = 0;
*(uint8_t*)0x20103d4b = 0;
*(uint8_t*)0x20103d4c = 0;
*(uint8_t*)0x20103d4d = 0;
*(uint8_t*)0x20103d4e = 0;
*(uint8_t*)0x20103d4f = 0;
*(uint8_t*)0x20103d50 = 0;
*(uint8_t*)0x20103d51 = 0;
*(uint8_t*)0x20103d52 = 0;
*(uint8_t*)0x20103d53 = 0;
*(uint8_t*)0x20103d54 = 0;
*(uint8_t*)0x20103d55 = 0;
*(uint8_t*)0x20103d56 = 0;
*(uint8_t*)0x20103d57 = 0xaa;
*(uint32_t*)0x20103d58 = htobe32(-1);
*(uint32_t*)0x20103d5c = htobe32(0);
*(uint32_t*)0x20103d60 = htobe32(0xff000000);
*(uint32_t*)0x20103d64 = htobe32(-1);
*(uint32_t*)0x20103d68 = htobe32(0xffffff00);
*(uint32_t*)0x20103d6c = htobe32(0xff);
*(uint32_t*)0x20103d70 = htobe32(0);
*(uint32_t*)0x20103d74 = htobe32(-1);
*(uint8_t*)0x20103d78 = 0x73;
*(uint8_t*)0x20103d79 = 0x79;
*(uint8_t*)0x20103d7a = 0x7a;
*(uint8_t*)0x20103d7b = 0x30;
*(uint8_t*)0x20103d7c = 0;
*(uint8_t*)0x20103d88 = 0x73;
*(uint8_t*)0x20103d89 = 0x79;
*(uint8_t*)0x20103d8a = 0x7a;
*(uint8_t*)0x20103d8b = 0x30;
*(uint8_t*)0x20103d8c = 0;
*(uint8_t*)0x20103d98 = 0;
*(uint8_t*)0x20103d99 = 0;
*(uint8_t*)0x20103d9a = 0;
*(uint8_t*)0x20103d9b = 0;
*(uint8_t*)0x20103d9c = 0;
*(uint8_t*)0x20103d9d = 0;
*(uint8_t*)0x20103d9e = 0;
*(uint8_t*)0x20103d9f = 0;
*(uint8_t*)0x20103da0 = 0;
*(uint8_t*)0x20103da1 = 0;
*(uint8_t*)0x20103da2 = 0;
*(uint8_t*)0x20103da3 = 0;
*(uint8_t*)0x20103da4 = 0;
*(uint8_t*)0x20103da5 = 0;
*(uint8_t*)0x20103da6 = 0;
*(uint8_t*)0x20103da7 = 0;
*(uint8_t*)0x20103da8 = -1;
*(uint8_t*)0x20103da9 = 0;
*(uint8_t*)0x20103daa = 0;
*(uint8_t*)0x20103dab = 0;
*(uint8_t*)0x20103dac = 0;
*(uint8_t*)0x20103dad = 0;
*(uint8_t*)0x20103dae = 0;
*(uint8_t*)0x20103daf = 0;
*(uint8_t*)0x20103db0 = 0;
*(uint8_t*)0x20103db1 = 0;
*(uint8_t*)0x20103db2 = 0;
*(uint8_t*)0x20103db3 = 0;
*(uint8_t*)0x20103db4 = 0;
*(uint8_t*)0x20103db5 = 0;
*(uint8_t*)0x20103db6 = 0;
*(uint8_t*)0x20103db7 = 0;
*(uint16_t*)0x20103db8 = 0;
*(uint8_t*)0x20103dba = 8;
*(uint8_t*)0x20103dbb = 4;
*(uint8_t*)0x20103dbc = 0x4b;
*(uint32_t*)0x20103dc0 = 0;
*(uint16_t*)0x20103dc4 = 0x100;
*(uint16_t*)0x20103dc6 = 0x128;
*(uint32_t*)0x20103dc8 = 0;
*(uint64_t*)0x20103dd0 = 0;
*(uint64_t*)0x20103dd8 = 0;
*(uint16_t*)0x20103de0 = 0x30;
memcpy((void*)0x20103de2, "\x61\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00",
29);
*(uint8_t*)0x20103dff = 0;
*(uint32_t*)0x20103e00 = htobe32(0x4d4);
*(uint32_t*)0x20103e04 = htobe32(0x4d4);
*(uint32_t*)0x20103e08 = 9;
*(uint8_t*)0x20103e0c = 0xf9;
*(uint8_t*)0x20103e0d = 1;
*(uint16_t*)0x20103e10 = 0x28;
memcpy((void*)0x20103e12, "\x68\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00",
29);
*(uint8_t*)0x20103e2f = 0;
*(uint8_t*)0x20103e30 = 0;
*(uint8_t*)0x20103e31 = 3;
*(uint16_t*)0x20103e38 = 0x28;
memcpy((void*)0x20103e3a, "\x54\x43\x50\x4d\x53\x53\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00",
29);
*(uint8_t*)0x20103e57 = 0;
*(uint16_t*)0x20103e58 = 3;
*(uint8_t*)0x20103e60 = 0;
*(uint8_t*)0x20103e61 = 0;
*(uint8_t*)0x20103e62 = 0;
*(uint8_t*)0x20103e63 = 0;
*(uint8_t*)0x20103e64 = 0;
*(uint8_t*)0x20103e65 = 0;
*(uint8_t*)0x20103e66 = 0;
*(uint8_t*)0x20103e67 = 0;
*(uint8_t*)0x20103e68 = 0;
*(uint8_t*)0x20103e69 = 0;
*(uint8_t*)0x20103e6a = 0;
*(uint8_t*)0x20103e6b = 0;
*(uint8_t*)0x20103e6c = 0;
*(uint8_t*)0x20103e6d = 0;
*(uint8_t*)0x20103e6e = 0;
*(uint8_t*)0x20103e6f = 0;
*(uint8_t*)0x20103e70 = 0;
*(uint8_t*)0x20103e71 = 0;
*(uint8_t*)0x20103e72 = 0;
*(uint8_t*)0x20103e73 = 0;
*(uint8_t*)0x20103e74 = 0;
*(uint8_t*)0x20103e75 = 0;
*(uint8_t*)0x20103e76 = 0;
*(uint8_t*)0x20103e77 = 0;
*(uint8_t*)0x20103e78 = 0;
*(uint8_t*)0x20103e79 = 0;
*(uint8_t*)0x20103e7a = 0;
*(uint8_t*)0x20103e7b = 0;
*(uint8_t*)0x20103e7c = 0;
*(uint8_t*)0x20103e7d = 0;
*(uint8_t*)0x20103e7e = 0;
*(uint8_t*)0x20103e7f = 0;
*(uint8_t*)0x20103e80 = 0;
*(uint8_t*)0x20103e81 = 0;
*(uint8_t*)0x20103e82 = 0;
*(uint8_t*)0x20103e83 = 0;
*(uint8_t*)0x20103e84 = 0;
*(uint8_t*)0x20103e85 = 0;
*(uint8_t*)0x20103e86 = 0;
*(uint8_t*)0x20103e87 = 0;
*(uint8_t*)0x20103e88 = 0;
*(uint8_t*)0x20103e89 = 0;
*(uint8_t*)0x20103e8a = 0;
*(uint8_t*)0x20103e8b = 0;
*(uint8_t*)0x20103e8c = 0;
*(uint8_t*)0x20103e8d = 0;
*(uint8_t*)0x20103e8e = 0;
*(uint8_t*)0x20103e8f = 0;
*(uint8_t*)0x20103e90 = 0;
*(uint8_t*)0x20103e91 = 0;
*(uint8_t*)0x20103e92 = 0;
*(uint8_t*)0x20103e93 = 0;
*(uint8_t*)0x20103e94 = 0;
*(uint8_t*)0x20103e95 = 0;
*(uint8_t*)0x20103e96 = 0;
*(uint8_t*)0x20103e97 = 0;
*(uint8_t*)0x20103e98 = 0;
*(uint8_t*)0x20103e99 = 0;
*(uint8_t*)0x20103e9a = 0;
*(uint8_t*)0x20103e9b = 0;
*(uint8_t*)0x20103e9c = 0;
*(uint8_t*)0x20103e9d = 0;
*(uint8_t*)0x20103e9e = 0;
*(uint8_t*)0x20103e9f = 0;
*(uint8_t*)0x20103ea0 = 0;
*(uint8_t*)0x20103ea1 = 0;
*(uint8_t*)0x20103ea2 = 0;
*(uint8_t*)0x20103ea3 = 0;
*(uint8_t*)0x20103ea4 = 0;
*(uint8_t*)0x20103ea5 = 0;
*(uint8_t*)0x20103ea6 = 0;
*(uint8_t*)0x20103ea7 = 0;
*(uint8_t*)0x20103ea8 = 0;
*(uint8_t*)0x20103ea9 = 0;
*(uint8_t*)0x20103eaa = 0;
*(uint8_t*)0x20103eab = 0;
*(uint8_t*)0x20103eac = 0;
*(uint8_t*)0x20103ead = 0;
*(uint8_t*)0x20103eae = 0;
*(uint8_t*)0x20103eaf = 0;
*(uint8_t*)0x20103eb0 = 0;
*(uint8_t*)0x20103eb1 = 0;
*(uint8_t*)0x20103eb2 = 0;
*(uint8_t*)0x20103eb3 = 0;
*(uint8_t*)0x20103eb4 = 0;
*(uint8_t*)0x20103eb5 = 0;
*(uint8_t*)0x20103eb6 = 0;
*(uint8_t*)0x20103eb7 = 0;
*(uint8_t*)0x20103eb8 = 0;
*(uint8_t*)0x20103eb9 = 0;
*(uint8_t*)0x20103eba = 0;
*(uint8_t*)0x20103ebb = 0;
*(uint8_t*)0x20103ebc = 0;
*(uint8_t*)0x20103ebd = 0;
*(uint8_t*)0x20103ebe = 0;
*(uint8_t*)0x20103ebf = 0;
*(uint8_t*)0x20103ec0 = 0;
*(uint8_t*)0x20103ec1 = 0;
*(uint8_t*)0x20103ec2 = 0;
*(uint8_t*)0x20103ec3 = 0;
*(uint8_t*)0x20103ec4 = 0;
*(uint8_t*)0x20103ec5 = 0;
*(uint8_t*)0x20103ec6 = 0;
*(uint8_t*)0x20103ec7 = 0;
*(uint8_t*)0x20103ec8 = 0;
*(uint8_t*)0x20103ec9 = 0;
*(uint8_t*)0x20103eca = 0;
*(uint8_t*)0x20103ecb = 0;
*(uint8_t*)0x20103ecc = 0;
*(uint8_t*)0x20103ecd = 0;
*(uint8_t*)0x20103ece = 0;
*(uint8_t*)0x20103ecf = 0;
*(uint8_t*)0x20103ed0 = 0;
*(uint8_t*)0x20103ed1 = 0;
*(uint8_t*)0x20103ed2 = 0;
*(uint8_t*)0x20103ed3 = 0;
*(uint8_t*)0x20103ed4 = 0;
*(uint8_t*)0x20103ed5 = 0;
*(uint8_t*)0x20103ed6 = 0;
*(uint8_t*)0x20103ed7 = 0;
*(uint8_t*)0x20103ed8 = 0;
*(uint8_t*)0x20103ed9 = 0;
*(uint8_t*)0x20103eda = 0;
*(uint8_t*)0x20103edb = 0;
*(uint8_t*)0x20103edc = 0;
*(uint8_t*)0x20103edd = 0;
*(uint8_t*)0x20103ede = 0;
*(uint8_t*)0x20103edf = 0;
*(uint8_t*)0x20103ee0 = 0;
*(uint8_t*)0x20103ee1 = 0;
*(uint8_t*)0x20103ee2 = 0;
*(uint8_t*)0x20103ee3 = 0;
*(uint8_t*)0x20103ee4 = 0;
*(uint8_t*)0x20103ee5 = 0;
*(uint8_t*)0x20103ee6 = 0;
*(uint8_t*)0x20103ee7 = 0;
*(uint32_t*)0x20103ee8 = 0;
*(uint16_t*)0x20103eec = 0xa8;
*(uint16_t*)0x20103eee = 0xd0;
*(uint32_t*)0x20103ef0 = 0;
*(uint64_t*)0x20103ef8 = 0;
*(uint64_t*)0x20103f00 = 0;
*(uint16_t*)0x20103f08 = 0x28;
memcpy((void*)0x20103f0a, "\x53\x45\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00",
29);
*(uint8_t*)0x20103f27 = 1;
*(uint16_t*)0x20103f28 = 0x81;
*(uint8_t*)0x20103f2a = 8;
*(uint8_t*)0x20103f2b = 3;
*(uint16_t*)0x20103f2c = 3;
*(uint8_t*)0x20103f2e = -1;
*(uint8_t*)0x20103f2f = 4;
*(uint8_t*)0x20103f30 = 0;
*(uint8_t*)0x20103f31 = 0;
*(uint8_t*)0x20103f32 = 0;
*(uint8_t*)0x20103f33 = 0;
*(uint8_t*)0x20103f34 = 0;
*(uint8_t*)0x20103f35 = 0;
*(uint8_t*)0x20103f36 = 0;
*(uint8_t*)0x20103f37 = 0;
*(uint8_t*)0x20103f38 = 0;
*(uint8_t*)0x20103f39 = 0;
*(uint8_t*)0x20103f3a = 0;
*(uint8_t*)0x20103f3b = 0;
*(uint8_t*)0x20103f3c = 0;
*(uint8_t*)0x20103f3d = 0;
*(uint8_t*)0x20103f3e = 0;
*(uint8_t*)0x20103f3f = 0;
*(uint8_t*)0x20103f40 = 0;
*(uint8_t*)0x20103f41 = 0;
*(uint8_t*)0x20103f42 = 0;
*(uint8_t*)0x20103f43 = 0;
*(uint8_t*)0x20103f44 = 0;
*(uint8_t*)0x20103f45 = 0;
*(uint8_t*)0x20103f46 = 0;
*(uint8_t*)0x20103f47 = 0;
*(uint8_t*)0x20103f48 = 0;
*(uint8_t*)0x20103f49 = 0;
*(uint8_t*)0x20103f4a = 0;
*(uint8_t*)0x20103f4b = 0;
*(uint8_t*)0x20103f4c = 0;
*(uint8_t*)0x20103f4d = 0;
*(uint8_t*)0x20103f4e = 0;
*(uint8_t*)0x20103f4f = 0;
*(uint8_t*)0x20103f50 = 0;
*(uint8_t*)0x20103f51 = 0;
*(uint8_t*)0x20103f52 = 0;
*(uint8_t*)0x20103f53 = 0;
*(uint8_t*)0x20103f54 = 0;
*(uint8_t*)0x20103f55 = 0;
*(uint8_t*)0x20103f56 = 0;
*(uint8_t*)0x20103f57 = 0;
*(uint8_t*)0x20103f58 = 0;
*(uint8_t*)0x20103f59 = 0;
*(uint8_t*)0x20103f5a = 0;
*(uint8_t*)0x20103f5b = 0;
*(uint8_t*)0x20103f5c = 0;
*(uint8_t*)0x20103f5d = 0;
*(uint8_t*)0x20103f5e = 0;
*(uint8_t*)0x20103f5f = 0;
*(uint8_t*)0x20103f60 = 0;
*(uint8_t*)0x20103f61 = 0;
*(uint8_t*)0x20103f62 = 0;
*(uint8_t*)0x20103f63 = 0;
*(uint8_t*)0x20103f64 = 0;
*(uint8_t*)0x20103f65 = 0;
*(uint8_t*)0x20103f66 = 0;
*(uint8_t*)0x20103f67 = 0;
*(uint8_t*)0x20103f68 = 0;
*(uint8_t*)0x20103f69 = 0;
*(uint8_t*)0x20103f6a = 0;
*(uint8_t*)0x20103f6b = 0;
*(uint8_t*)0x20103f6c = 0;
*(uint8_t*)0x20103f6d = 0;
*(uint8_t*)0x20103f6e = 0;
*(uint8_t*)0x20103f6f = 0;
*(uint8_t*)0x20103f70 = 0;
*(uint8_t*)0x20103f71 = 0;
*(uint8_t*)0x20103f72 = 0;
*(uint8_t*)0x20103f73 = 0;
*(uint8_t*)0x20103f74 = 0;
*(uint8_t*)0x20103f75 = 0;
*(uint8_t*)0x20103f76 = 0;
*(uint8_t*)0x20103f77 = 0;
*(uint8_t*)0x20103f78 = 0;
*(uint8_t*)0x20103f79 = 0;
*(uint8_t*)0x20103f7a = 0;
*(uint8_t*)0x20103f7b = 0;
*(uint8_t*)0x20103f7c = 0;
*(uint8_t*)0x20103f7d = 0;
*(uint8_t*)0x20103f7e = 0;
*(uint8_t*)0x20103f7f = 0;
*(uint8_t*)0x20103f80 = 0;
*(uint8_t*)0x20103f81 = 0;
*(uint8_t*)0x20103f82 = 0;
*(uint8_t*)0x20103f83 = 0;
*(uint8_t*)0x20103f84 = 0;
*(uint8_t*)0x20103f85 = 0;
*(uint8_t*)0x20103f86 = 0;
*(uint8_t*)0x20103f87 = 0;
*(uint8_t*)0x20103f88 = 0;
*(uint8_t*)0x20103f89 = 0;
*(uint8_t*)0x20103f8a = 0;
*(uint8_t*)0x20103f8b = 0;
*(uint8_t*)0x20103f8c = 0;
*(uint8_t*)0x20103f8d = 0;
*(uint8_t*)0x20103f8e = 0;
*(uint8_t*)0x20103f8f = 0;
*(uint8_t*)0x20103f90 = 0;
*(uint8_t*)0x20103f91 = 0;
*(uint8_t*)0x20103f92 = 0;
*(uint8_t*)0x20103f93 = 0;
*(uint8_t*)0x20103f94 = 0;
*(uint8_t*)0x20103f95 = 0;
*(uint8_t*)0x20103f96 = 0;
*(uint8_t*)0x20103f97 = 0;
*(uint8_t*)0x20103f98 = 0;
*(uint8_t*)0x20103f99 = 0;
*(uint8_t*)0x20103f9a = 0;
*(uint8_t*)0x20103f9b = 0;
*(uint8_t*)0x20103f9c = 0;
*(uint8_t*)0x20103f9d = 0;
*(uint8_t*)0x20103f9e = 0;
*(uint8_t*)0x20103f9f = 0;
*(uint8_t*)0x20103fa0 = 0;
*(uint8_t*)0x20103fa1 = 0;
*(uint8_t*)0x20103fa2 = 0;
*(uint8_t*)0x20103fa3 = 0;
*(uint8_t*)0x20103fa4 = 0;
*(uint8_t*)0x20103fa5 = 0;
*(uint8_t*)0x20103fa6 = 0;
*(uint8_t*)0x20103fa7 = 0;
*(uint8_t*)0x20103fa8 = 0;
*(uint8_t*)0x20103fa9 = 0;
*(uint8_t*)0x20103faa = 0;
*(uint8_t*)0x20103fab = 0;
*(uint8_t*)0x20103fac = 0;
*(uint8_t*)0x20103fad = 0;
*(uint8_t*)0x20103fae = 0;
*(uint8_t*)0x20103faf = 0;
*(uint8_t*)0x20103fb0 = 0;
*(uint8_t*)0x20103fb1 = 0;
*(uint8_t*)0x20103fb2 = 0;
*(uint8_t*)0x20103fb3 = 0;
*(uint8_t*)0x20103fb4 = 0;
*(uint8_t*)0x20103fb5 = 0;
*(uint8_t*)0x20103fb6 = 0;
*(uint8_t*)0x20103fb7 = 0;
*(uint32_t*)0x20103fb8 = 0;
*(uint16_t*)0x20103fbc = 0xa8;
*(uint16_t*)0x20103fbe = 0xd0;
*(uint32_t*)0x20103fc0 = 0;
*(uint64_t*)0x20103fc8 = 0;
*(uint64_t*)0x20103fd0 = 0;
*(uint16_t*)0x20103fd8 = 0x28;
memcpy((void*)0x20103fda, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00",
29);
*(uint8_t*)0x20103ff7 = 0;
*(uint32_t*)0x20103ff8 = 0xfffffffe;
syscall(__NR_setsockopt, r[0], 0x29, 0x40, 0x20103ba0, 0x460);
break;
}
}
void test()
{
memset(r, -1, sizeof(r));
execute(3);
}
int main()
{
for (;;) {
loop();
}
}
|
the_stack_data/238983.c | #include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
int main(){
int n, sum;
scanf("%d", &n);
while (n > 0){
sum += (n % 10);
n = n / 10;
}
printf("%d", sum);
return 0;
}
|
the_stack_data/251049.c | #include <stdio.h>
int main() {
printf("A line to stdout\n");
fprintf(stderr, "A line to stderr\n");
return(0);
}
|
the_stack_data/173579406.c | /*
* Test of floats and doubles.
*/
double f(x)
double x;
{
return 3.14*x;
}
main()
{
double x;
float y;
y = 3.0;
x = f(y);
return 0;
}
|
the_stack_data/82951523.c | // Author: Chungha Sung
// This is a modified version of Blink LED Demo from
// http://processors.wiki.ti.com/index.php/MSP430_LaunchPad_LED_Timer
// Below is the original source code and C version of this code.
//***************************************************************************************
// MSP430 Timer Blink LED Demo - Timer A Software Toggle P1.0 & P1.6
//
// Description; Toggle P1.0 and P1.6 by xor'ing them inside of a software loop.
// Since the clock is running at 1Mhz, an overflow counter will count to 8 and then toggle
// the LED. This way the LED toggles every 0.5s.
// ACLK = n/a, MCLK = SMCLK = default DCO
//
// MSP430G2xx
// -----------------
// /|\| XIN|-
// | | |
// --|RST XOUT|-
// | P1.6|-->LED
// | P1.0|-->LED
//
// Aldo Briano
// Texas Instruments, Inc
// June 2010
// Built with Code Composer Studio v4
//***************************************************************************************
/*
#include <msp430g2231.h>
#define LED_0 BIT0
#define LED_1 BIT6
#define LED_OUT P1OUT
#define LED_DIR P1DIR
unsigned int timerCount = 0;
void main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
LED_DIR |= (LED_0 + LED_1); // Set P1.0 and P1.6 to output direction
LED_OUT &= ~(LED_0 + LED_1); // Set the LEDs off
CCTL0 = CCIE;
TACTL = TASSEL_2 + MC_2; // Set the timer A to SMCLCK, Continuous
// Clear the timer and enable timer interrupt
__enable_interrupt();
__bis_SR_register(LPM0 + GIE); // LPM0 with interrupts enabled
}
// Timer A0 interrupt service routine
#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
timerCount = (timerCount + 1) % 8;
if(timerCount ==0)
P1OUT ^= (LED_0 + LED_1);
}
*/
#include <stdio.h>
#include <pthread.h>
#include <assert.h>
unsigned int timerCount = 0;
int P1OUT;
int LED_0;
int LED_1;
int WDTCLT;
int WDTPW;
int WDTCTL;
int WDTHOLD;
int LED_DIR;
int LED_OUT;
int CCTL0;
int CCIE;
int TACTL;
int TASSEL_2;
int MC_2;
#define LIMIT 20
int cnt1, cnt2, cnt3, cnt4;
// Timer A0 interrupt service routine
// Priority 3
void *Timer_A (void *unused)
{
//while (cnt1 < LIMIT) {
//timerCount = (timerCount + 1) % 8;
timerCount = (timerCount + 1);
// traditional: violated
// our method: violated
// assert(timerCount == 0);
if (timerCount != 0) {
assert(0);
}
if(timerCount == 0) {
P1OUT = (LED_0 + LED_1);
}
//cnt1++;
//}
}
// Priority 2
void *Timer_B (void *unused)
{
//while (cnt2 < LIMIT) {
timerCount = 0;
// traditional: violated
// our method: not violated
// assert(timerCount == 0);
if (timerCount != 0) {
assert(0);
}
if (timerCount == 0) {
P1OUT = LED_0;
}
//cnt2++;
//}
}
// Priority 4
void *Timer_C (void *unused)
{
//while (cnt3 < LIMIT) {
timerCount = 0;
// traditional: violated
// our method: not violated
// assert(timerCount == 0);
if (timerCount != 0) {
assert(0);
}
if (timerCount == 0) {
P1OUT = LED_0;
}
//cnt3++;
//}
}
// Priority 3
void *Timer_Force (void* unused)
{
//while (cnt4 < LIMIT) {
timerCount = 1;
//cnt4++;
//}
}
int main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
//LED_DIR |= (LED_0 + LED_1); // Set P1.0 and P1.6 to output direction
LED_DIR = LED_0 + LED_1;
//LED_OUT &= ~(LED_0 + LED_1); // Set the LEDs off
LED_OUT = 1 + (LED_0+LED_1);
CCTL0 = CCIE;
TACTL = TASSEL_2 + MC_2; // Set the timer A to SMCLCK, Continuous
// Clear the timer and enable timer interrupt
timerCount = 0;
pthread_t t1, t2, t3, t4;
pthread_create(&t1, 0, Timer_A, 0);
pthread_create(&t2, 0, Timer_B, 0);
pthread_create(&t3, 0, Timer_C, 0);
pthread_create(&t4, 0, Timer_Force, 0);
//__bis_SR_register(LPM0 + GIE); // LPM0 with interrupts enabled
}
|
the_stack_data/289305.c | //
// Created by zhangrongxiang on 2017/10/12 10:53
// File addr
//
#include <stdio.h>
#include <arpa/inet.h>
int main() {
//32bit int
unsigned long addr = inet_addr("192.168.0.100");
printf("addr = %ud\n", ntohl(addr));//转换成主机字节序
struct in_addr ipaddr;
ipaddr.s_addr = addr;
printf("%s\n", inet_ntoa(ipaddr));//转成成点分十进制
return 0;
} |
the_stack_data/153267055.c | /*
Visualizar la tarifa de luz según el gasto de corriente eléctrica
Para un gasto menor de 1.000 Kw la tarifa es de 1.2
Entre 1.000 y 1.850 Kw es de 1.0
Y mayor de 1.850 Kw es de 0.9
*/
#include <stdio.h>
#define PI 3.1416
#define TARIFA1 1.2
#define TARIFA2 1.0
#define TARIFA3 0.9
int main(){
float fGasto = 0;
//printf("El valor de PI es: %f",PI);
printf("Ingrese el total de gastos de energ%ca: ",161);
scanf("%f",&fGasto);
if(fGasto < 1000){
printf("\nLa tasa a pagar es de: %.2f",TARIFA1);
}else if(fGasto >= 1000 && fGasto <= 1850){
printf("\nLa tasa a pagar es de: %.2f",TARIFA2);
}else{
printf("\nLa tasa a pagar es de: %.2f",TARIFA3 );
}
return 0;
}//fin int main
|
the_stack_data/107322.c | /*
* Derived from:
* http://www.kernel.org/pub/linux/libs/klibc/
*/
/*
* strcpy.c
*
* strcpy()
*/
#include <string.h>
char *strcpy(char *dst, const char *src) {
char *q = dst;
const char *p = src;
char ch;
do {
*q++ = ch = *p++;
} while (ch);
return dst;
}
|
the_stack_data/87997.c | /* mbed Microcontroller Library
*******************************************************************************
* Copyright (c) 2017, STMicroelectronics
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************
*/
#if DEVICE_SERIAL
#include "serial_api_hal.h"
#if defined (TARGET_STM32F031K6)
#define UART_NUM (1)
#elif defined (TARGET_STM32F030R8) || defined (TARGET_STM32F051R8) || defined (TARGET_STM32F042K6)
#define UART_NUM (2)
#elif defined (TARGET_STM32F070RB) || defined (TARGET_STM32F072RB)
#define UART_NUM (4)
#else
#define UART_NUM (8) // max value (TARGET_STM32F091RC)
#endif
uint32_t serial_irq_ids[UART_NUM] = {0};
UART_HandleTypeDef uart_handlers[UART_NUM];
static uart_irq_handler irq_handler;
// Defined in serial_api.c
extern int8_t get_uart_index(UARTName uart_name);
/******************************************************************************
* INTERRUPTS HANDLING
******************************************************************************/
static void uart_irq(UARTName uart_name)
{
int8_t id = get_uart_index(uart_name);
if (id >= 0) {
UART_HandleTypeDef *huart = &uart_handlers[id];
if (serial_irq_ids[id] != 0) {
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_TXE) != RESET) {
irq_handler(serial_irq_ids[id], TxIrq);
}
}
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) {
irq_handler(serial_irq_ids[id], RxIrq);
/* Flag has been cleared when reading the content */
}
}
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);
}
}
}
}
}
#if defined(USART1_BASE)
static void uart1_irq(void)
{
uart_irq(UART_1);
}
#endif
#if defined(USART2_BASE)
static void uart2_irq(void)
{
uart_irq(UART_2);
}
#endif
// Used for both USART3_4_IRQn and USART3_8_IRQn
static void uart3_8_irq(void)
{
#if defined(TARGET_STM32F091RC)
#if defined(USART3_BASE)
if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART3) != RESET) {
uart_irq(UART_3);
}
#endif
#if defined(USART4_BASE)
if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART4) != RESET) {
uart_irq(UART_4);
}
#endif
#if defined(USART5_BASE)
if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART5) != RESET) {
uart_irq(UART_5);
}
#endif
#if defined(USART6_BASE)
if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART6) != RESET) {
uart_irq(UART_6);
}
#endif
#if defined(USART7_BASE)
if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART7) != RESET) {
uart_irq(UART_7);
}
#endif
#if defined(USART8_BASE)
if (__HAL_GET_PENDING_IT(HAL_ITLINE_USART8) != RESET) {
uart_irq(UART_8);
}
#endif
#else // TARGET_STM32F070RB, TARGET_STM32F072RB
#if defined(USART3_BASE)
if (USART3->ISR & (UART_FLAG_TXE | UART_FLAG_RXNE | UART_FLAG_ORE)) {
uart_irq(UART_3);
}
#endif
#if defined(USART4_BASE)
if (USART4->ISR & (UART_FLAG_TXE | UART_FLAG_RXNE | UART_FLAG_ORE)) {
uart_irq(UART_4);
}
#endif
#endif
}
void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id)
{
struct serial_s *obj_s = SERIAL_S(obj);
irq_handler = handler;
serial_irq_ids[obj_s->index] = id;
}
void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
IRQn_Type irq_n = (IRQn_Type)0;
uint32_t vector = 0;
#if defined(USART1_BASE)
if (obj_s->uart == UART_1) {
irq_n = USART1_IRQn;
vector = (uint32_t)&uart1_irq;
}
#endif
#if defined(USART2_BASE)
if (obj_s->uart == UART_2) {
irq_n = USART2_IRQn;
vector = (uint32_t)&uart2_irq;
}
#endif
#if defined(USART3_BASE)
if (obj_s->uart == UART_3) {
#if defined(TARGET_STM32F091RC)
irq_n = USART3_8_IRQn;
#else
irq_n = USART3_4_IRQn;
#endif
vector = (uint32_t)&uart3_8_irq;
}
#endif
#if defined(USART4_BASE)
if (obj_s->uart == UART_4) {
#if defined(TARGET_STM32F091RC)
irq_n = USART3_8_IRQn;
#else
irq_n = USART3_4_IRQn;
#endif
vector = (uint32_t)&uart3_8_irq;
}
#endif
// Below usart are available only on TARGET_STM32F091RC
#if defined(USART5_BASE)
if (obj_s->uart == UART_5) {
irq_n = USART3_8_IRQn;
vector = (uint32_t)&uart3_8_irq;
}
#endif
#if defined(USART6_BASE)
if (obj_s->uart == UART_6) {
irq_n = USART3_8_IRQn;
vector = (uint32_t)&uart3_8_irq;
}
#endif
#if defined(USART7_BASE)
if (obj_s->uart == UART_7) {
irq_n = USART3_8_IRQn;
vector = (uint32_t)&uart3_8_irq;
}
#endif
#if defined(USART8_BASE)
if (obj_s->uart == UART_8) {
irq_n = USART3_8_IRQn;
vector = (uint32_t)&uart3_8_irq;
}
#endif
if (enable) {
if (irq == RxIrq) {
__HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
} else { // TxIrq
__HAL_UART_ENABLE_IT(huart, UART_IT_TXE);
}
NVIC_SetVector(irq_n, vector);
NVIC_EnableIRQ(irq_n);
} else { // disable
int all_disabled = 0;
if (irq == RxIrq) {
__HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
// Check if TxIrq is disabled too
if ((huart->Instance->CR1 & USART_CR1_TXEIE) == 0) {
all_disabled = 1;
}
} else { // TxIrq
__HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
// Check if RxIrq is disabled too
if ((huart->Instance->CR1 & USART_CR1_RXNEIE) == 0) {
all_disabled = 1;
}
}
if (all_disabled) {
NVIC_DisableIRQ(irq_n);
}
}
}
/******************************************************************************
* READ/WRITE
******************************************************************************/
int serial_getc(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
while (!serial_readable(obj));
return (int)(huart->Instance->RDR & (uint16_t)0xFF);
}
void serial_putc(serial_t *obj, int c)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
while (!serial_writable(obj));
huart->Instance->TDR = (uint32_t)(c & (uint16_t)0xFF);
}
void serial_clear(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
huart->TxXferCount = 0;
huart->RxXferCount = 0;
}
void serial_break_set(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart __attribute__((unused)) = &uart_handlers[obj_s->index];
}
#if DEVICE_SERIAL_ASYNCH
/******************************************************************************
* LOCAL HELPER FUNCTIONS
******************************************************************************/
/**
* Configure the TX buffer for an asynchronous write serial transaction
*
* @param obj The serial object.
* @param tx The buffer for sending.
* @param tx_length The number of words to transmit.
*/
static void serial_tx_buffer_set(serial_t *obj, void *tx, int tx_length, uint8_t width)
{
(void)width;
// Exit if a transmit is already on-going
if (serial_tx_active(obj)) {
return;
}
obj->tx_buff.buffer = tx;
obj->tx_buff.length = tx_length;
obj->tx_buff.pos = 0;
}
/**
* Configure the RX buffer for an asynchronous write serial transaction
*
* @param obj The serial object.
* @param tx The buffer for sending.
* @param tx_length The number of words to transmit.
*/
static void serial_rx_buffer_set(serial_t *obj, void *rx, int rx_length, uint8_t width)
{
(void)width;
// Exit if a reception is already on-going
if (serial_rx_active(obj)) {
return;
}
obj->rx_buff.buffer = rx;
obj->rx_buff.length = rx_length;
obj->rx_buff.pos = 0;
}
/**
* Configure events
*
* @param obj The serial object
* @param event The logical OR of the events to configure
* @param enable Set to non-zero to enable events, or zero to disable them
*/
static void serial_enable_event(serial_t *obj, int event, uint8_t enable)
{
struct serial_s *obj_s = SERIAL_S(obj);
// Shouldn't have to enable interrupt here, just need to keep track of the requested events.
if (enable) {
obj_s->events |= event;
} else {
obj_s->events &= ~event;
}
}
/**
* Get index of serial object TX IRQ, relating it to the physical peripheral.
*
* @param uart_name i.e. UART_1, UART_2, ...
* @return internal NVIC TX IRQ index of U(S)ART peripheral
*/
static IRQn_Type serial_get_irq_n(UARTName uart_name)
{
IRQn_Type irq_n;
switch (uart_name) {
#if defined(USART1_BASE)
case UART_1:
irq_n = USART1_IRQn;
break;
#endif
#if defined(USART2_BASE)
case UART_2:
irq_n = USART2_IRQn;
break;
#endif
#if defined(USART3_BASE)
case UART_3:
#if defined (TARGET_STM32F091RC)
irq_n = USART3_8_IRQn;
#else
irq_n = USART3_4_IRQn;
#endif
break;
#endif
#if defined(USART4_BASE)
case UART_4:
#if defined (TARGET_STM32F091RC)
irq_n = USART3_8_IRQn;
#else
irq_n = USART3_4_IRQn;
#endif
break;
#endif
#if defined(USART5_BASE)
case UART_5:
irq_n = USART3_8_IRQn;
break;
#endif
#if defined(USART6_BASE)
case UART_6:
irq_n = USART3_8_IRQn;
break;
#endif
#if defined(USART7_BASE)
case UART_7:
irq_n = USART3_8_IRQn;
break;
#endif
#if defined(USART8_BASE)
case UART_8:
irq_n = USART3_8_IRQn;
break;
#endif
default:
irq_n = (IRQn_Type)0;
}
return irq_n;
}
/******************************************************************************
* MBED API FUNCTIONS
******************************************************************************/
/**
* Begin asynchronous TX transfer. The used buffer is specified in the serial
* object, tx_buff
*
* @param obj The serial object
* @param tx The buffer for sending
* @param tx_length The number of words to transmit
* @param tx_width The bit width of buffer word
* @param handler The serial handler
* @param event The logical OR of events to be registered
* @param hint A suggestion for how to use DMA with this transfer
* @return Returns number of data transfered, or 0 otherwise
*/
int serial_tx_asynch(serial_t *obj, const void *tx, size_t tx_length, uint8_t tx_width, uint32_t handler, uint32_t event, DMAUsage hint)
{
// TODO: DMA usage is currently ignored
(void) hint;
// Check buffer is ok
MBED_ASSERT(tx != (void *)0);
MBED_ASSERT(tx_width == 8); // support only 8b width
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
if (tx_length == 0) {
return 0;
}
// Set up buffer
serial_tx_buffer_set(obj, (void *)tx, tx_length, tx_width);
// Set up events
serial_enable_event(obj, SERIAL_EVENT_TX_ALL, 0); // Clear all events
serial_enable_event(obj, event, 1); // Set only the wanted events
// Enable interrupt
IRQn_Type irq_n = serial_get_irq_n(obj_s->uart);
NVIC_ClearPendingIRQ(irq_n);
NVIC_DisableIRQ(irq_n);
NVIC_SetPriority(irq_n, 1);
NVIC_SetVector(irq_n, (uint32_t)handler);
NVIC_EnableIRQ(irq_n);
// the following function will enable UART_IT_TXE and error interrupts
if (HAL_UART_Transmit_IT(huart, (uint8_t *)tx, tx_length) != HAL_OK) {
return 0;
}
return tx_length;
}
/**
* Begin asynchronous RX transfer (enable interrupt for data collecting)
* The used buffer is specified in the serial object, rx_buff
*
* @param obj The serial object
* @param rx The buffer for sending
* @param rx_length The number of words to transmit
* @param rx_width The bit width of buffer word
* @param handler The serial handler
* @param event The logical OR of events to be registered
* @param handler The serial handler
* @param char_match A character in range 0-254 to be matched
* @param hint A suggestion for how to use DMA with this transfer
*/
void serial_rx_asynch(serial_t *obj, void *rx, size_t rx_length, uint8_t rx_width, uint32_t handler, uint32_t event, uint8_t char_match, DMAUsage hint)
{
// TODO: DMA usage is currently ignored
(void) hint;
/* Sanity check arguments */
MBED_ASSERT(obj);
MBED_ASSERT(rx != (void *)0);
MBED_ASSERT(rx_width == 8); // support only 8b width
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
serial_enable_event(obj, SERIAL_EVENT_RX_ALL, 0);
serial_enable_event(obj, event, 1);
// set CharMatch
obj->char_match = char_match;
serial_rx_buffer_set(obj, rx, rx_length, rx_width);
IRQn_Type irq_n = serial_get_irq_n(obj_s->uart);
NVIC_ClearPendingIRQ(irq_n);
NVIC_DisableIRQ(irq_n);
NVIC_SetPriority(irq_n, 0);
NVIC_SetVector(irq_n, (uint32_t)handler);
NVIC_EnableIRQ(irq_n);
// following HAL function will enable the RXNE interrupt + error interrupts
HAL_UART_Receive_IT(huart, (uint8_t *)rx, rx_length);
}
/**
* Attempts to determine if the serial peripheral is already in use for TX
*
* @param obj The serial object
* @return Non-zero if the TX transaction is ongoing, 0 otherwise
*/
uint8_t serial_tx_active(serial_t *obj)
{
MBED_ASSERT(obj);
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
return (((HAL_UART_GetState(huart) & HAL_UART_STATE_BUSY_TX) == HAL_UART_STATE_BUSY_TX) ? 1 : 0);
}
/**
* Attempts to determine if the serial peripheral is already in use for RX
*
* @param obj The serial object
* @return Non-zero if the RX transaction is ongoing, 0 otherwise
*/
uint8_t serial_rx_active(serial_t *obj)
{
MBED_ASSERT(obj);
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
return (((HAL_UART_GetState(huart) & HAL_UART_STATE_BUSY_RX) == HAL_UART_STATE_BUSY_RX) ? 1 : 0);
}
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);
}
}
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_PEF);
}
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_FEF);
}
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_NE) != RESET) {
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_NEF);
}
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);
}
}
/**
* The asynchronous TX and RX handler.
*
* @param obj The serial object
* @return Returns event flags if a TX/RX transfer termination condition was met or 0 otherwise
*/
int serial_irq_handler_asynch(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
volatile int return_event = 0;
uint8_t *buf = (uint8_t *)(obj->rx_buff.buffer);
uint8_t i = 0;
// TX PART:
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {
// Return event SERIAL_EVENT_TX_COMPLETE if requested
if ((obj_s->events & SERIAL_EVENT_TX_COMPLETE) != 0) {
return_event |= (SERIAL_EVENT_TX_COMPLETE & obj_s->events);
}
}
}
// Handle error events
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) {
return_event |= (SERIAL_EVENT_RX_PARITY_ERROR & obj_s->events);
}
}
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) {
return_event |= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events);
}
}
if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
if (__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) {
return_event |= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);
}
}
HAL_UART_IRQHandler(huart);
// Abort if an error occurs
if ((return_event & SERIAL_EVENT_RX_PARITY_ERROR) ||
(return_event & SERIAL_EVENT_RX_FRAMING_ERROR) ||
(return_event & SERIAL_EVENT_RX_OVERRUN_ERROR)) {
return return_event;
}
//RX PART
if (huart->RxXferSize != 0) {
obj->rx_buff.pos = huart->RxXferSize - huart->RxXferCount;
}
if ((huart->RxXferCount == 0) && (obj->rx_buff.pos >= (obj->rx_buff.length - 1))) {
return_event |= (SERIAL_EVENT_RX_COMPLETE & obj_s->events);
}
// Check if char_match is present
if (obj_s->events & SERIAL_EVENT_RX_CHARACTER_MATCH) {
if (buf != NULL) {
for (i = 0; i < obj->rx_buff.pos; i++) {
if (buf[i] == obj->char_match) {
obj->rx_buff.pos = i;
return_event |= (SERIAL_EVENT_RX_CHARACTER_MATCH & obj_s->events);
serial_rx_abort_asynch(obj);
break;
}
}
}
}
return return_event;
}
/**
* Abort the ongoing TX transaction. It disables the enabled interupt for TX and
* flush TX hardware buffer if TX FIFO is used
*
* @param obj The serial object
*/
void serial_tx_abort_asynch(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
__HAL_UART_DISABLE_IT(huart, UART_IT_TC);
__HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
// clear flags
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);
// reset states
huart->TxXferCount = 0;
// update handle state
if (huart->gState == HAL_UART_STATE_BUSY_TX_RX) {
huart->gState = HAL_UART_STATE_BUSY_RX;
} else {
huart->gState = HAL_UART_STATE_READY;
}
}
/**
* Abort the ongoing RX transaction It disables the enabled interrupt for RX and
* flush RX hardware buffer if RX FIFO is used
*
* @param obj The serial object
*/
void serial_rx_abort_asynch(serial_t *obj)
{
struct serial_s *obj_s = SERIAL_S(obj);
UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
// disable interrupts
__HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
__HAL_UART_DISABLE_IT(huart, UART_IT_PE);
__HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
// clear flags
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_PEF | UART_CLEAR_FEF | UART_CLEAR_OREF);
volatile uint32_t tmpval __attribute__((unused)) = huart->Instance->RDR; // Clear RXNE flag
// reset states
huart->RxXferCount = 0;
// update handle state
if (huart->RxState == HAL_UART_STATE_BUSY_TX_RX) {
huart->RxState = HAL_UART_STATE_BUSY_TX;
} else {
huart->RxState = HAL_UART_STATE_READY;
}
}
#endif /* DEVICE_SERIAL_ASYNCH */
#if DEVICE_SERIAL_FC
/**
* Set HW Control Flow
* @param obj The serial object
* @param type The Control Flow type (FlowControlNone, FlowControlRTS, FlowControlCTS, FlowControlRTSCTS)
* @param rxflow Pin for the rxflow
* @param txflow Pin for the txflow
*/
void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow)
{
struct serial_s *obj_s = SERIAL_S(obj);
// Determine the UART to use (UART_1, UART_2, ...)
UARTName uart_rts = (UARTName)pinmap_peripheral(rxflow, PinMap_UART_RTS);
UARTName uart_cts = (UARTName)pinmap_peripheral(txflow, PinMap_UART_CTS);
// Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object
obj_s->uart = (UARTName)pinmap_merge(uart_cts, uart_rts);
MBED_ASSERT(obj_s->uart != (UARTName)NC);
if (type == FlowControlNone) {
// Disable hardware flow control
obj_s->hw_flow_ctl = UART_HWCONTROL_NONE;
}
if (type == FlowControlRTS) {
// Enable RTS
MBED_ASSERT(uart_rts != (UARTName)NC);
obj_s->hw_flow_ctl = UART_HWCONTROL_RTS;
obj_s->pin_rts = rxflow;
// Enable the pin for RTS function
pinmap_pinout(rxflow, PinMap_UART_RTS);
}
if (type == FlowControlCTS) {
// Enable CTS
MBED_ASSERT(uart_cts != (UARTName)NC);
obj_s->hw_flow_ctl = UART_HWCONTROL_CTS;
obj_s->pin_cts = txflow;
// Enable the pin for CTS function
pinmap_pinout(txflow, PinMap_UART_CTS);
}
if (type == FlowControlRTSCTS) {
// Enable CTS & RTS
MBED_ASSERT(uart_rts != (UARTName)NC);
MBED_ASSERT(uart_cts != (UARTName)NC);
obj_s->hw_flow_ctl = UART_HWCONTROL_RTS_CTS;
obj_s->pin_rts = rxflow;
obj_s->pin_cts = txflow;
// Enable the pin for CTS function
pinmap_pinout(txflow, PinMap_UART_CTS);
// Enable the pin for RTS function
pinmap_pinout(rxflow, PinMap_UART_RTS);
}
init_uart(obj);
}
#endif /* DEVICE_SERIAL_FC */
#endif /* DEVICE_SERIAL */
|
the_stack_data/184519058.c | /*Exercise 3 - Repetition
Write a C program to calculate the sum of the numbers from 1 to n.
Where n is a keyboard input.
e.g.
n -> 100
sum = 1+2+3+....+ 99+100 = 5050
n -> 1-
sum = 1+2+3+...+10 = 55 */
#include <stdio.h>
int main() {
int n,i;
int sum;
sum = 0;
printf("Enter the number:");
scanf("%d",&n);
for(i=1; i<=n; ++i){
sum += i;
}
printf("The sum is = %d\n",sum);
return 0;
}
|
the_stack_data/120464.c | int
main()
{
char *p;
p = "hello";
return p[0] - 104;
}
|
the_stack_data/32949197.c | #include <stdio.h>
int main (){
int temp;
printf ("Digite a temperatura: ");
scanf ("%d", &temp);
if (temp < 10){
printf("Temperatura muito fria \n");
}
else if (temp < 20){
printf("Temperatura fria \n");
}
else if ( temp < 30){
printf ("Temperatura agradavel \n");
}
else {
printf ("Temperatura quente");
}
}
|
the_stack_data/117327598.c | //---- GPL ---------------------------------------------------------------------
//
// Copyright (C) Stichting Deltares, 2011-2016.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation version 3.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// contact: [email protected]
// Stichting Deltares
// P.O. Box 177
// 2600 MH Delft, The Netherlands
//
// All indications and logos of, and references to, "Delft3D" and "Deltares"
// are registered trademarks of Stichting Deltares, and remain the property of
// Stichting Deltares. All rights reserved.
//
//------------------------------------------------------------------------------
// $Id: writetofile.c 5717 2016-01-12 11:35:24Z mourits $
// $HeadURL: https://svn.oss.deltares.nl/repos/delft3d/tags/6686/src/engines_gpl/flow2d3d/packages/data/src/parallel_mpi/writetofile.c $
#include<assert.h>
#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void writetofilef_(float *a, int *n1, int *n2, int *n3, int *it, char *jtname)
{
FILE *fp;
float *data;
int i,j;
size_t nmemb, nwrite;
char filename[1024];
fprintf(stderr,"Float n1=%d n2=%d n3=%d timestep=%d jtname=%s\n",*n1, *n2, *n3, *it, jtname);
sprintf(filename,"Array%03d_%03d_%03d_%03d_%s.bin",*it, *n1, *n2, *n3, jtname);
fprintf(stderr,"filename = %s\n", filename);
nmemb = (*n1);
data = (float *)calloc(nmemb,sizeof(float));
fp = fopen(filename, "w+");
for (i=0; i<(*n2)*(*n3); i++) {
for (j=0; j<(*n1); j++) {
data[j] = (float)a[i*(*n1)+j];
// fprintf(stderr,"data[%d]=%e, %e\n", j, data[j], a[i*(*n1)+j]);
// if ( fpclassify(data[j]) != FP_NORMAL) {
// fprintf(stderr,"nan for time %d at point n=%d m=%d\n", *it, j, i);
// data[j] = -1.0;
// }
}
nwrite = fwrite(data, sizeof(float), nmemb, fp);
assert(nwrite==nmemb);
}
fflush(fp);
fclose(fp);
free(data);
return;
}
void writetofilei_(int *a, int *n1, int *n2, int *n3, int *it, char *jtname)
{
FILE *fp;
float *data;
int i,j;
size_t nmemb, nwrite;
char filename[1024];
fprintf(stderr,"Float n1=%d n2=%d n3=%d timestep=%d jtname=%s\n",*n1, *n2, *n3, *it, jtname);
sprintf(filename,"ArrayI%03d_%03d_%03d_%03d_%s.bin",*it, *n1, *n2, *n3, jtname);
fprintf(stderr,"filename = %s\n", filename);
nmemb = (*n1);
data = (float *)calloc(nmemb,sizeof(float));
fp = fopen(filename, "w+");
for (i=0; i<(*n2)*(*n3); i++) {
for (j=0; j<(*n1); j++) {
data[j] = (float)a[i*(*n1)+j];
// fprintf(stderr,"data[%d]=%e, %e\n", j, data[j], a[i*(*n1)+j]);
// if ( fpclassify(data[j]) != FP_NORMAL) {
// fprintf(stderr,"nan for time %d at point n=%d m=%d\n", *it, j, i);
// data[j] = -1.0;
// }
}
nwrite = fwrite(data, sizeof(float), nmemb, fp);
assert(nwrite==nmemb);
}
fflush(fp);
fclose(fp);
free(data);
return;
}
void random_nmbr_(float *r)
{
*r = (float)drand48();
}
|
the_stack_data/65182.c | #include <pthread.h>
void thread(void func(void *), void *args) {
pthread_t thread_temp;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 1 << 20);
pthread_create(&thread_temp, &attr, (void *(*)(void *))func, args);
pthread_attr_destroy(&attr);
}
|
the_stack_data/57949564.c | #include <stdio.h>
typedef long long int ll;
ll dp[2005][2005],a[2005][2005];
ll min(ll,ll);
int main(void){
int N,M,i,j;
scanf("%d%d",&N,&M);
for(i=0;i<M;++i)
for(j=0;j<N;++j)
scanf("%lld",a[i]+j);
for(i=N;i>=0;--i)
for(j=M-1;j>=0;--j)
dp[j][i]=min(dp[(j+1)%M][i+1]+a[j][i],dp[j][i+1]+a[j][i]);
#ifdef DEBUG
for(i=0;i<M;++i){
for(j=0;j<N;++j) printf("%2lld ",dp[i][j]);
putchar('\n');
}
#endif
ll ans=dp[0][0];
for(i=1;i<M;++i) if(dp[i][0]<ans) ans=dp[i][0];
printf("%lld\n",ans);
return 0;
}
ll min(ll a,ll b){
if(a>b) return b;
return a;
}
|
the_stack_data/165766327.c | // File: 5.16.c
// Author: TaoKY
#include <stdio.h>
#include <stdlib.h>
void printChar(char c, int x);
int main(){
for (int i = 3; i >= -3; i--){
printChar(' ', abs(i));
printChar('*', (3 - abs(i)) * 2 + 1);
puts("");
}
return 0;
}
void printChar(char c, int x){
for (int i = 0; i < x; i++)
putchar(c);
}
|
the_stack_data/122937.c | // RUN: %clang_cc1 -triple mips-unknown-linux-gnu -S -emit-llvm -o - %s | FileCheck -check-prefix=O32 %s
// RUN: %clang_cc1 -triple mipsel-unknown-linux-gnu -S -emit-llvm -o - %s | FileCheck -check-prefix=O32 %s
// RUN: %clang_cc1 -triple mipsisa32r6-unknown-linux-gnu -S -emit-llvm -o - %s | FileCheck -check-prefix=O32 %s
// RUN: %clang_cc1 -triple mipsisa32r6el-unknown-linux-gnu -S -emit-llvm -o - %s | FileCheck -check-prefix=O32 %s
// RUN: %clang_cc1 -triple mips64-unknown-linux-gnu -S -emit-llvm -o - %s -target-abi n32 | FileCheck -check-prefix=N32 %s
// RUN: %clang_cc1 -triple mips64el-unknown-linux-gnu -S -emit-llvm -o - %s -target-abi n32 | FileCheck -check-prefix=N32 %s
// RUN: %clang_cc1 -triple mipsisa64r6-unknown-linux-gnu -S -emit-llvm -o - %s -target-abi n32 | FileCheck -check-prefix=N32 %s
// RUN: %clang_cc1 -triple mipsisa64r6el-unknown-linux-gnu -S -emit-llvm -o - %s -target-abi n32 | FileCheck -check-prefix=N32 %s
// RUN: %clang_cc1 -triple mips64-unknown-linux-gnuabin32 -S -emit-llvm -o - %s | FileCheck -check-prefix=N32 %s
// RUN: %clang_cc1 -triple mips64el-unknown-linux-gnuabin32 -S -emit-llvm -o - %s | FileCheck -check-prefix=N32 %s
// RUN: %clang_cc1 -triple mipsisa64r6-unknown-linux-gnuabin32 -S -emit-llvm -o - %s | FileCheck -check-prefix=N32 %s
// RUN: %clang_cc1 -triple mipsisa64r6el-unknown-linux-gnuabin32 -S -emit-llvm -o - %s | FileCheck -check-prefix=N32 %s
// RUN: %clang_cc1 -triple mips64-unknown-linux-gnu -S -emit-llvm -o - %s | FileCheck -check-prefix=N64 %s
// RUN: %clang_cc1 -triple mips64el-unknown-linux-gnu -S -emit-llvm -o - %s | FileCheck -check-prefix=N64 %s
// RUN: %clang_cc1 -triple mipsisa64r6-unknown-linux-gnu -S -emit-llvm -o - %s | FileCheck -check-prefix=N64 %s
// RUN: %clang_cc1 -triple mipsisa64r6el-unknown-linux-gnu -S -emit-llvm -o - %s | FileCheck -check-prefix=N64 %s
// RUN: %clang_cc1 -triple mips64-unknown-linux-gnuabi64 -S -emit-llvm -o - %s | FileCheck -check-prefix=N64 %s
// RUN: %clang_cc1 -triple mips64el-unknown-linux-gnuabi64 -S -emit-llvm -o - %s | FileCheck -check-prefix=N64 %s
// RUN: %clang_cc1 -triple mipsisa64r6-unknown-linux-gnuabi64 -S -emit-llvm -o - %s | FileCheck -check-prefix=N64 %s
// RUN: %clang_cc1 -triple mipsisa64r6el-unknown-linux-gnuabi64 -S -emit-llvm -o - %s | FileCheck -check-prefix=N64 %s
// O32: define void @fn28(%struct.T2* noalias sret(%struct.T2) align 1 %agg.result, i8 signext %arg0)
// N32: define void @fn28(i8 signext %arg0)
// N64: define void @fn28(i8 signext %arg0)
typedef struct T2 { } T2;
T2 T2_retval;
T2 fn28(char arg0) {
return T2_retval;
}
|
the_stack_data/70449063.c | /**
* src/Component/RISC-V/riscv_api.c
* Copyright (c) 2020 Virus.V <[email protected]>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
|
the_stack_data/72013453.c | #include<stdio.h>
int main()
{
float r;
printf("area of circul ");
scanf("%f",&r);
printf("arae of circul is %f \n",3.14*r*r);
printf("volume of circul");
scanf("%f",&r);
printf("volume of circul is %f",1.333*3.14*r*r);
}
|
the_stack_data/155239.c | /*More on pointers*/
#include <stdio.h>
int main (void)
{
int i1, i2;
int *p1, *p2;
i1 = 5;
p1 = &i1;
i2 = *p1 / 2 + 10;
p2 = p1;
printf ("i1 = %i, i2 = %i, *p1 = %i, *p2 = %i\n", i1, i2, *p1, *p2);
return 0;
}
|
the_stack_data/492864.c | #include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[]) {
int a = 5;
int b = -2;
unsigned aU = 5;
unsigned bU = 2;
int cC = a+1;
int cV = a+b;
int dC = a-1;
int dV = a-b;
int eC = a*2;
int eV = a*b;
unsigned fuC = aU/5;
int fsC = a/5;
unsigned fuV = aU/bU;
int fsV = a/b;
unsigned guC = aU%5;
int gsC = a%5;
unsigned guV = aU%bU;
int gsV = a%b;
int hC = a << 1;
int hV = a << bU;
unsigned iuC = aU >> 1;
int isC = a >> 1;
unsigned iuV = aU >> bU;
int isV = a >> bU;
int jC = a & 1;
int jV = a & bU;
int kC = a | 1;
int kV = a | bU;
int lC = a^1;
int lV = a^bU;
}
|
the_stack_data/13904.c | int x = 72;
int main(void) {
return x;
}
|
the_stack_data/4507.c | /* Example code for Think OS.
Copyright 2014 Allen Downey
License: GNU GPLv3
*/
#include <stdio.h>
#include <stdlib.h>
int var1;
int main ()
{
int var2 = 5;
// A randomnly selected number - 30
void *ra = malloc(30);
void *rb = malloc(30);
// void *p = malloc(128);
// The systems heap grows upwards
// void *b = malloc(1280);
// char *s = "Hello, World";
printf ("Address of main is %p\n", main);
local(var2);
printf ("Address of var2 is %p\n", &var2);
// printf ("p points to %p\n", p);
// printf ("b points to %p\n", b);
// printf ("s points to %p\n", s);
printf ("ra points to %p\n", ra);
printf ("rb points to %p\n", rb);
// The distance between them turns out to be -28
return 0;
}
int local (int var)
{
// The memory space grows toward lower addresses
printf ("Address of function2 is %p\n", local);
printf ("Address of variable %i is: %p\n", var, &var);
}
|
the_stack_data/6386857.c | #include <stdio.h>
int main(int argc, char *argv[])
{
int a, b, remainder;
scanf("%d%d", &a, &b);
while (b != 0)
{
remainder = b;
b = a % b;
a = remainder;
}
printf("%d", a);
return 0;
} |
the_stack_data/156392794.c | #ifdef COMPILE_FOR_TEST
#include <assert.h>
#define assume(cond) assert(cond)
#endif
void main(int argc, char* argv[]) {
int x_0_0;//sh_buf.outcnt
int x_0_1;//sh_buf.outcnt
int x_0_2;//sh_buf.outcnt
int x_0_3;//sh_buf.outcnt
int x_0_4;//sh_buf.outcnt
int x_0_5;//sh_buf.outcnt
int x_0_6;//sh_buf.outcnt
int x_0_7;//sh_buf.outcnt
int x_1_0;//sh_buf.outbuf[0]
int x_1_1;//sh_buf.outbuf[0]
int x_2_0;//sh_buf.outbuf[1]
int x_2_1;//sh_buf.outbuf[1]
int x_3_0;//sh_buf.outbuf[2]
int x_3_1;//sh_buf.outbuf[2]
int x_4_0;//sh_buf.outbuf[3]
int x_4_1;//sh_buf.outbuf[3]
int x_5_0;//sh_buf.outbuf[4]
int x_5_1;//sh_buf.outbuf[4]
int x_6_0;//sh_buf.outbuf[5]
int x_7_0;//sh_buf.outbuf[6]
int x_8_0;//sh_buf.outbuf[7]
int x_9_0;//sh_buf.outbuf[8]
int x_10_0;//sh_buf.outbuf[9]
int x_11_0;//LOG_BUFSIZE
int x_11_1;//LOG_BUFSIZE
int x_12_0;//CREST_scheduler::lock_0
int x_13_0;//t3 T0
int x_14_0;//t2 T0
int x_15_0;//arg T0
int x_16_0;//functioncall::param T0
int x_16_1;//functioncall::param T0
int x_17_0;//buffered T0
int x_18_0;//functioncall::param T0
int x_18_1;//functioncall::param T0
int x_19_0;//functioncall::param T0
int x_19_1;//functioncall::param T0
int x_20_0;//functioncall::param T0
int x_20_1;//functioncall::param T0
int x_21_0;//functioncall::param T0
int x_21_1;//functioncall::param T0
int x_22_0;//direction T0
int x_23_0;//functioncall::param T0
int x_23_1;//functioncall::param T0
int x_24_0;//functioncall::param T0
int x_24_1;//functioncall::param T0
int x_25_0;//functioncall::param T0
int x_25_1;//functioncall::param T0
int x_26_0;//functioncall::param T0
int x_26_1;//functioncall::param T0
int x_27_0;//functioncall::param T0
int x_27_1;//functioncall::param T0
int x_28_0;//functioncall::param T0
int x_28_1;//functioncall::param T0
int x_29_0;//functioncall::param T0
int x_29_1;//functioncall::param T0
int x_30_0;//functioncall::param T0
int x_30_1;//functioncall::param T0
int x_31_0;//functioncall::param T0
int x_31_1;//functioncall::param T0
int x_32_0;//functioncall::param T0
int x_32_1;//functioncall::param T0
int x_33_0;//functioncall::param T0
int x_33_1;//functioncall::param T0
int x_34_0;//functioncall::param T0
int x_34_1;//functioncall::param T0
int x_35_0;//functioncall::param T1
int x_35_1;//functioncall::param T1
int x_36_0;//functioncall::param T1
int x_36_1;//functioncall::param T1
int x_37_0;//i T1
int x_37_1;//i T1
int x_37_2;//i T1
int x_38_0;//rv T1
int x_39_0;//rv T1
int x_39_1;//rv T1
int x_40_0;//functioncall::param T1
int x_40_1;//functioncall::param T1
int x_41_0;//functioncall::param T1
int x_41_1;//functioncall::param T1
int x_42_0;//functioncall::param T1
int x_42_1;//functioncall::param T1
int x_43_0;//functioncall::param T1
int x_43_1;//functioncall::param T1
int x_44_0;//functioncall::param T1
int x_44_1;//functioncall::param T1
int x_45_0;//functioncall::param T1
int x_45_1;//functioncall::param T1
int x_46_0;//functioncall::param T1
int x_46_1;//functioncall::param T1
int x_47_0;//functioncall::param T1
int x_47_1;//functioncall::param T1
int x_48_0;//functioncall::param T1
int x_48_1;//functioncall::param T1
int x_49_0;//functioncall::param T2
int x_49_1;//functioncall::param T2
int x_50_0;//functioncall::param T2
int x_50_1;//functioncall::param T2
int x_51_0;//i T2
int x_51_1;//i T2
int x_51_2;//i T2
int x_51_3;//i T2
int x_52_0;//rv T2
int x_53_0;//rv T2
int x_53_1;//rv T2
int x_54_0;//functioncall::param T2
int x_54_1;//functioncall::param T2
int x_55_0;//functioncall::param T2
int x_55_1;//functioncall::param T2
int x_56_0;//functioncall::param T2
int x_56_1;//functioncall::param T2
int x_57_0;//functioncall::param T2
int x_57_1;//functioncall::param T2
int x_58_0;//functioncall::param T2
int x_58_1;//functioncall::param T2
int x_59_0;//functioncall::param T2
int x_59_1;//functioncall::param T2
int x_59_2;//functioncall::param T2
int x_60_0;//functioncall::param T2
int x_60_1;//functioncall::param T2
T_0_0_0: x_0_0 = 0;
T_0_1_0: x_1_0 = 0;
T_0_2_0: x_2_0 = 0;
T_0_3_0: x_3_0 = 0;
T_0_4_0: x_4_0 = 0;
T_0_5_0: x_5_0 = 0;
T_0_6_0: x_6_0 = 0;
T_0_7_0: x_7_0 = 0;
T_0_8_0: x_8_0 = 0;
T_0_9_0: x_9_0 = 0;
T_0_10_0: x_10_0 = 0;
T_0_11_0: x_11_0 = 0;
T_0_12_0: x_13_0 = 3694299248;
T_0_13_0: x_14_0 = 3982221920;
T_0_14_0: x_15_0 = 0;
T_0_15_0: x_16_0 = 570036076;
T_0_16_0: x_16_1 = -1;
T_0_17_0: x_17_0 = 0;
T_0_18_0: x_18_0 = 2000383999;
T_0_19_0: x_18_1 = x_17_0;
T_0_20_0: x_19_0 = 1373700686;
T_0_21_0: x_19_1 = 97;
T_0_22_0: x_20_0 = 324057233;
T_0_23_0: x_20_1 = 0;
T_0_24_0: x_21_0 = 1244850609;
T_0_25_0: x_21_1 = 0;
T_0_26_0: x_22_0 = -312750016;
T_0_27_0: x_23_0 = 630309609;
T_0_28_0: x_23_1 = x_22_0;
T_0_29_0: x_24_0 = 830574491;
T_0_30_0: x_24_1 = 0;
T_0_31_0: x_12_0 = -1;
T_0_32_0: x_0_1 = 5;
T_0_33_0: x_1_1 = 72;
T_0_34_0: x_2_1 = 69;
T_0_35_0: x_3_1 = 76;
T_0_36_0: x_4_1 = 76;
T_0_37_0: x_5_1 = 79;
T_0_38_0: x_25_0 = 1060777381;
T_0_39_0: x_25_1 = 83;
T_0_40_0: x_26_0 = 1307850528;
T_0_41_0: x_26_1 = 1;
T_0_42_0: x_27_0 = 4443387;
T_0_43_0: x_27_1 = 1;
T_0_44_0: x_28_0 = 1412034228;
T_0_45_0: x_28_1 = 1;
T_0_46_0: x_29_0 = 124821362;
T_0_47_0: x_29_1 = 82;
T_0_48_0: x_30_0 = 1759070518;
T_0_49_0: x_30_1 = 90;
T_0_50_0: x_31_0 = 1289491897;
T_0_51_0: x_31_1 = 1;
T_0_52_0: x_32_0 = 844503986;
T_0_53_0: x_32_1 = 1;
T_0_54_0: x_33_0 = 1318541636;
T_0_55_0: x_33_1 = 2;
T_0_56_0: x_34_0 = 326742742;
T_0_57_0: x_34_1 = 2;
T_0_58_0: x_11_1 = 5;
T_1_59_1: x_35_0 = 559726656;
T_1_60_1: x_35_1 = x_27_1;
T_1_61_1: x_36_0 = 1930432611;
T_1_62_1: x_36_1 = x_28_1;
T_1_63_1: x_37_0 = 0;
T_1_64_1: x_38_0 = 264188417;
T_2_65_2: x_49_0 = 1507848975;
T_2_66_2: x_49_1 = x_33_1;
T_2_67_2: x_50_0 = 2097618580;
T_2_68_2: x_50_1 = x_34_1;
T_2_69_2: x_51_0 = 0;
T_2_70_2: x_52_0 = 262087169;
T_2_71_2: if (x_0_1 + x_50_1 > x_11_1 && x_0_1 != 0) x_53_0 = -305682512;
T_1_72_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_39_0 = -305682512;
T_1_73_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_40_0 = 936701391;
T_1_74_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_40_1 = -1;
T_1_75_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_39_1 = x_40_1;
T_1_76_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_39_1 + 1 == 0) x_0_2 = 0;
T_1_77_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_41_0 = 1514368800;
T_1_78_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_41_1 = 9;
T_1_79_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_42_0 = 156516755;
T_1_80_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_42_1 = x_41_1;
T_1_81_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_0_3 = 0;
T_1_82_1: if (x_0_1 + x_50_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_54_0 = 242302374;
T_1_83_1: if (x_0_1 + x_50_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_54_1 = -1;
T_1_84_1: if (x_0_1 + x_50_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_53_1 = x_54_1;
T_2_85_2: if (x_0_1 + x_50_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_53_1 + 1 == 0) x_0_4 = 0;
T_2_86_2: if (x_36_1 < x_11_1) x_43_0 = 316905879;
T_2_87_2: if (x_36_1 < x_11_1) x_43_1 = 47970225542912;
T_2_88_2: if (x_36_1 < x_11_1) x_44_0 = 554790714;
T_1_89_1: if (x_36_1 < x_11_1) x_44_1 = x_0_4 + x_36_1;
T_1_90_1: if (x_36_1 < x_11_1) x_37_1 = 0;
T_1_91_1: if (x_36_1 < x_11_1 && x_37_1 < x_35_1) x_45_0 = 1795628759;
T_1_92_1: if (x_36_1 < x_11_1 && x_37_1 < x_35_1) x_45_1 = 47970225542912;
T_1_93_1: if (x_36_1 < x_11_1) x_37_2 = 1 + x_37_1;
T_1_94_1: if (x_36_1 < x_11_1) x_46_0 = 1067989354;
T_1_95_1: if (x_36_1 < x_11_1) x_46_1 = 47970225542912;
T_1_96_1: if (x_0_1 + x_50_1 > x_11_1 && x_0_1 != 0) x_55_0 = 1435748249;
T_1_97_1: if (x_0_1 + x_50_1 > x_11_1 && x_0_1 != 0) x_55_1 = 9;
T_1_98_1: if (x_0_1 + x_50_1 > x_11_1 && x_0_1 != 0) x_56_0 = 626308536;
T_1_99_1: if (x_0_1 + x_50_1 > x_11_1 && x_0_1 != 0) x_56_1 = x_55_1;
T_2_100_2: if (x_0_1 + x_50_1 > x_11_1 && x_0_1 != 0) x_0_5 = 0;
T_2_101_2: if (x_50_1 < x_11_1) x_57_0 = 1638025431;
T_2_102_2: if (x_50_1 < x_11_1) x_57_1 = 47970227644160;
T_2_103_2: if (x_36_1 < x_11_1) x_0_6 = x_0_4 + x_36_1;
T_2_104_2: if (x_50_1 < x_11_1) x_58_0 = 1288648600;
T_2_105_2: if (x_50_1 < x_11_1) x_58_1 = x_0_5 + x_50_1;
T_2_106_2: if (x_50_1 < x_11_1) x_51_1 = 0;
T_2_107_2: if (x_50_1 < x_11_1 && x_51_1 < x_49_1) x_59_0 = 2000009222;
T_2_108_2: if (x_50_1 < x_11_1 && x_51_1 < x_49_1) x_59_1 = 47970227644160;
T_2_109_2: if (x_50_1 < x_11_1) x_51_2 = 1 + x_51_1;
T_2_110_2: if (x_50_1 < x_11_1 && x_51_2 < x_49_1) x_59_2 = 47970227644160;
T_2_111_2: if (x_50_1 < x_11_1) x_51_3 = 1 + x_51_2;
T_2_112_2: if (x_50_1 < x_11_1) x_60_0 = 1962082664;
T_2_113_2: if (x_50_1 < x_11_1) x_60_1 = 47970227644160;
T_2_114_2: if (x_36_1 < x_11_1) x_47_0 = 386015562;
T_2_115_2: if (x_36_1 < x_11_1) x_47_1 = 47970225542912;
T_2_116_2: if (x_50_1 < x_11_1) x_0_7 = x_0_6 + x_50_1;
T_2_117_2: if (x_36_1 < x_11_1) x_48_0 = 482835183;
T_1_118_1: if (x_36_1 < x_11_1) x_48_1 = 47970225542912;
T_1_119_1: if (x_36_1 < x_11_1) assert(x_0_7 == x_44_1);
}
|
the_stack_data/74350.c | #include <stdio.h>
#define ADJUST 7.31
int main(void)
{
const double SCALE = 0.333;
double shoe, foot;
shoe = 9.0;
foot = SCALE * shoe + ADJUST;
printf("Shoe size (men's) foot lenght\n");
printf("%10.1f %15.2f inches\n", shoe, foot);
return 0;
} |
the_stack_data/179830215.c | /*-
* Copyright (c) 1990, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Chris Torek.
*
* %sccs.include.redist.c%
*/
#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)ferror.c 8.1 (Berkeley) 06/04/93";
#endif /* LIBC_SCCS and not lint */
#include <stdio.h>
/*
* A subroutine version of the macro ferror.
*/
#undef ferror
ferror(fp)
FILE *fp;
{
return (__sferror(fp));
}
|
the_stack_data/53416.c | //Confusing tool to turn .pbm fonts into compressed RREs for RFB
#include <stdio.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define ECHARS 256
#define MAX_RECTS_PER_CHAR 100
#define DOUBLEPACK
int cw, ch;
int w, h;
int bytes;
uint8_t * buff;
struct MRect
{
uint8_t x, y, w, h;
};
int ReadFile( const char * rn );
void DumpBuffer( uint8_t * dat, int len, char * name )
{
printf( "const unsigned char %s[%d] = {", name, len );
int i;
for( i = 0; i < len; i++ )
{
if( (i%16) == 0 )
{
printf( "\n\t" );
}
printf( "0x%02x, ", dat[i] );
}
printf( "\n};\n\n" );
}
void DumpBuffer16( uint16_t * dat, int len, char * name )
{
printf( "const unsigned short %s[%d] = {", name, len );
int i;
for( i = 0; i < len; i++ )
{
if( (i%16) == 0 )
{
printf( "\n\t" );
}
printf( "0x%04x, ", dat[i] );
}
printf( "\n};\n\n" );
}
int TryCover( uint8_t * ibuff, struct MRect * r )
{
int x, y;
int count = 0;
for( y = r->y; y < r->y+r->h; y++ )
{
for( x = r->x; x < r->x+r->w; x++ )
{
if( ibuff[x+y*cw] == 1 ) count++;
else if( ibuff[x+y*cw] == 0 ) return -1;
}
}
return count;
}
void DoCover( uint8_t * ibuff, struct MRect * r )
{
int x, y;
int count = 0;
for( y = r->y; y < r->y+r->h; y++ )
{
for( x = r->x; x < r->x+r->w; x++ )
{
if( ibuff[x+y*cw] > 0 ) ibuff[x+y*cw]++;
}
}
}
int Covers( uint8_t * ibuff, struct MRect * rs )
{
int i;
int x, y, w, h;
for( i = 0; i < MAX_RECTS_PER_CHAR; i++ )
{
struct MRect most_efficient, tmp;
int most_efficient_count = 0;
for( y = 0; y < ch; y++ )
for( x = 0; x < cw; x++ )
for( h = 1; h <= ch-y; h++ )
for( w = 1; w <= cw-x; w++ )
{
#ifdef DOUBLEPACK
if( w > 16 || h > 16 || x > 16 || y > 16 ) continue;
#endif
tmp.x = x; tmp.y = y; tmp.w = w; tmp.h = h;
int ct = TryCover( ibuff, &tmp );
if( ct > most_efficient_count )
{
memcpy( &most_efficient, &tmp, sizeof( tmp ) );
most_efficient_count = ct;
}
}
if( most_efficient_count == 0 )
{
return i;
}
DoCover( ibuff, &most_efficient );
memcpy( &rs[i], &most_efficient, sizeof( struct MRect ) );
}
fprintf( stderr, "Error: too many rects per char.\n ");
exit( -22 );
}
int GreedyChar( int chr, int debug, struct MRect * RectSet )
{
int x, y, i;
uint8_t cbuff[ch*cw];
int rectcount;
for( y = 0; y < ch; y++ )
for( x = 0; x < cw/8; x++ )
{
int ppcx = w/cw;
int xpos = (chr % ppcx)*cw;
int ypos = (chr / ppcx)*ch;
int idx = xpos/8+(ypos+y)*w/8+x;
int inpos = buff[idx];
for( i = 0; i < 8; i++ )
{
cbuff[x*8+y*cw+i] = (inpos&(1<<(7-i)))?0:1;
}
}
//Greedily find the minimum # of rectangles that can cover this.
rectcount = Covers( cbuff, RectSet );
if( debug )
{
printf( "Char %d:\n", chr );
for( i = 0; i < rectcount; i++ )
{
printf( " %d %d %d %d\n", RectSet[i].x, RectSet[i].y, RectSet[i].w, RectSet[i].h );
}
printf( "\n" );
//Print a char for test.
printf( "%d\n", ch );
for( y = 0; y < ch; y++ )
{
for( x = 0; x < cw; x++ )
{
printf( "%d", cbuff[x+y*cw] );
}
printf( "\n" );
}
}
return rectcount;
}
int main( int argc, char ** argv )
{
int r, i, x, y, j;
if( argc != 4 )
{
fprintf( stderr, "Got %d args.\nUsage: [tool] [input_pbm] [char w] [char h]\n", argc );
return -1;
}
if( (r = ReadFile( argv[1] )) )
{
return r;
}
cw = atoi( argv[2] );
ch = atoi( argv[3] );
printf( "#define FONT_CHAR_W %d\n", cw );
printf( "#define FONT_CHAR_H %d\n\n", ch );
if( ( cw % 8 ) != 0 )
{
fprintf( stderr, "Error: CW MUST be divisible by 8.\n" );
}
// struct MRect MRect rs;
// GreedyChar( 0xdc, 1, &rs );
struct MRect MRects[ECHARS*MAX_RECTS_PER_CHAR];
uint16_t places[ECHARS+1];
int place = 0;
for( i = 0; i < ECHARS; i++ )
{
places[i] = place;
place += GreedyChar( i, 0, &MRects[place] );
}
places[i] = place;
uint16_t outbuffer[ECHARS*MAX_RECTS_PER_CHAR*2];
for( i = 0; i < place; i++ )
{
int x = MRects[i].x;
int y = MRects[i].y;
int w = MRects[i].w;
int h = MRects[i].h;
if( w == 0 || w > 16 ) { fprintf( stderr, "Error: invalid W value\n" ); return -5; }
if( h == 0 || h > 16 ) { fprintf( stderr, "Error: invalid H value\n" ); return -5; }
if( x > 15 ) { fprintf( stderr, "Error: invalid X value\n" ); return -5; }
if( y > 15 ) { fprintf( stderr, "Error: invalid Y value\n" ); return -5; }
w--;
h--;
outbuffer[i] = x | (y<<4) | (w<<8) | (h<<12);
}
fprintf( stderr, "Total places: %d\n", place );
DumpBuffer16( outbuffer, place, "font_pieces" );
DumpBuffer16( places, ECHARS+1, "font_places" );
return 0;
}
int ReadFile( const char * rn )
{
int r;
char ct[1024];
char * cct;
FILE * f = fopen( rn, "r" );
if( !f )
{
fprintf( stderr, "Error: Cannot open file.\n" );
return -11;
}
if( fscanf( f, "%1023s\n", ct ) != 1 || strcmp( ct, "P4" ) != 0 )
{
fprintf( stderr, "Error: Expected P4 header.\n" );
return -2;
}
size_t sizin = 0;
cct = 0;
ssize_t s = getline( &cct, &sizin, f );
if( !cct || cct[0] != '#' )
{
fprintf( stderr, "Error: Need a comment line.\n" );
return -3;
}
free( cct );
if( (r = fscanf( f, "%d %d\n", &w, &h )) != 2 || w <= 0 || h <= 0 )
{
fprintf( stderr, "Error: Need w and h in pbm file. Got %d params. (%d %d)\n", r, w, h );
return -4;
}
bytes = (w*h)>>3;
buff = malloc( bytes );
r = fread( buff, 1, bytes, f );
if( r != bytes )
{
fprintf( stderr, "Error: Ran into EOF when reading file. (%d)\n",r );
return -5;
}
fclose( f );
return 0;
}
|
the_stack_data/94616.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
int main( int argc, char * argv[] ) {
int array_size = atoi(argv[1]);
int * array = malloc(sizeof(int)*array_size);
clock_t start, end;
double cpu_time_used;
start = clock();
printf( "Size: %d\n", array_size);
srand(23);
for ( int i = 0; i < array_size; i++ ) {
array[i] = (rand() % 100) + 1;
}
end = clock();
cpu_time_used = ((double)(end-start)) / CLOCKS_PER_SEC;
printf( "Element[4095]: %d\n", array[4095]);
printf( "Time: %s\n", cpu_time_used);
free(array);
exit( 0 );
}
|
the_stack_data/415776.c | /* $Id$ */
/*
* %ISC_START_LICENSE%
* ---------------------------------------------------------------------
* Copyright 2015-2016, Google, Inc.
* Copyright (c) 2007-2015, Pittsburgh Supercomputing Center (PSC).
* All rights reserved.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
* --------------------------------------------------------------------
* %END_LICENSE%
*/
#include <sys/param.h>
#include <stdint.h>
#include <stdio.h>
/*
* Display the hexadecimal representation of some data.
* @ptr: data to display.
* @len: number of bytes to display.
* @buf: buffer to place representation in; must be at least 2 * @len +
* 1 (for NUL);
*/
void
pfl_unpack_hex(const void *ptr, size_t len, char buf[])
{
const unsigned char *p = ptr;
const char tab[] = "0123456789abcdef";
char *t = buf;
size_t n;
for (n = 0; n < len; p++, n++) {
*t++ = tab[*p >> 4];
*t++ = tab[*p & 0xf];
}
*t = '\0';
}
/*
* Display the hexadecimal representation of some data.
* @ptr: data to display.
* @len: number of bytes to display.
*/
void
fprinthex(FILE *fp, const void *ptr, size_t len)
{
const unsigned char *p = ptr;
size_t n;
flockfile(fp);
for (n = 0; n < len; p++, n++) {
if (n) {
if (n % 32 == 0)
fprintf(fp, "\n");
else {
if (n % 8 == 0)
fprintf(fp, " ");
fprintf(fp, " ");
}
}
fprintf(fp, "%02x", *p);
}
fprintf(fp, "\n------------------------------------------\n");
funlockfile(fp);
}
/*
* Display the bit representation of some data in reverse.
* @ptr: data to display.
* @len: number of bytes to display.
*/
void
printvbinr(const void *ptr, size_t len)
{
const unsigned char *p;
size_t n;
int i;
flockfile(stdout);
for (n = 0, p = (const unsigned char *)ptr + len - 1; n < len;
p--, n++) {
if (n && n % 8 == 0)
printf("\n");
for (i = NBBY - 1; i >= 0; i--)
putchar((*p & (1 << i)) ? '1': '0');
if (n % 8 != 7 && n != len - 1)
putchar(' ');
}
putchar('\n');
funlockfile(stdout);
}
/*
* Display the bit representation of some data.
* @ptr: data to display.
* @len: number of bytes to display.
*/
void
printvbin(const void *ptr, size_t len)
{
const unsigned char *p = ptr;
size_t n;
int i;
flockfile(stdout);
for (n = 0, p = ptr; n < len; p++, n++) {
if (n && n % 8 == 0)
printf("\n");
for (i = 0; i < NBBY; i++)
putchar((*p & (1 << i)) ? '1': '0');
if (n % 8 != 7 && n != len - 1)
putchar(' ');
}
putchar('\n');
funlockfile(stdout);
}
|
the_stack_data/161081254.c | /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
* Copyright 1998-2018 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted only as authorized by the OpenLDAP
* Public License.
*
* A copy of this license is available in the file LICENSE in the
* top-level directory of the distribution or, alternatively, at
* <http://www.OpenLDAP.org/license.html>.
*/
static const char copyright[] =
"Copyright 1998-2018 The OpenLDAP Foundation. All rights reserved.\n"
"COPYING RESTRICTIONS APPLY\n";
const char __Version[] =
"@(#) $OpenLDAP: ldapcompare 2.4.47 (" __DATE__ " " __TIME__ ") $\n"
"\topenldap\n";
|
the_stack_data/165769331.c | /* Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <[email protected]>, 2002.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#if 0 /*def SHARED*/
/* This function does not serve a useful purpose in the thread library
implementation anymore. It used to be necessary when then kernel
could not shut down "processes" but this is not the case anymore.
We could theoretically provide an equivalent implementation but
this is not necessary since the kernel already does a much better
job than we ever could. */
void
__pthread_kill_other_threads_np (void)
{
}
#endif
|
the_stack_data/851037.c | #include <stdio.h>
#define MAX_LEN 1000
// return the length of the word
int getLine(char s[], int limit) {
int ch;
int i;
for (i = 0; i < limit -1 && (ch=getchar()) != EOF && ch != '\n'; ++i) {
s[i] = ch;
}
if (ch == '\n') {
s[i] = '\n';
++i;
}
s[i] = '\0';
return i;
}
void copy(char to[], char from []) {
int i;
i = 0;
while ( (to[i] = from[i]) != '\0') {
++i;
}
}
int main() {
char s[MAX_LEN];
int len;
while ( (len = getLine(s, MAX_LEN)) > 0) {
if (len > 10) {
printf("%s\n", s);
}
}
return 0;
}
|
the_stack_data/26700375.c | #include <stdio.h>
void main() {
// char *pmessage = "print this";
char pmessage[] = "print this";
printf("%d", *pmessage);
}
|
the_stack_data/67325487.c | /*
Um-Dois-Três
https://www.urionlinejudge.com.br/judge/pt/problems/view/1332
*/
#include <stdio.h>
#include <string.h>
#define TO_UPPER(c) ((c) >= 'a' && (c) <= 'z' ? (c) - 0x20 : (c))
void analisarPalavra(const char *palavra);
int caracteresIguais(const char *palavra, const char *str);
#define STRING_SIZE 32
int main (void) {
int casos;
char palavra[STRING_SIZE];
scanf("%d\n", &casos);
while (casos-- > 0) {
scanf("%s\n", palavra);
analisarPalavra(palavra);
}
return 0;
}
void analisarPalavra(const char *palavra) {
if (caracteresIguais(palavra, "one") >= 2) {
printf("1\n");
}
else if (caracteresIguais(palavra, "two") >= 2) {
printf("2\n");
}
else if (caracteresIguais(palavra, "three") >= 4) {
printf("3\n");
}
}
int caracteresIguais(const char *palavra, const char *str) {
int i = 0,
quantidadeDeCaracteresIguais = 0;
while (palavra[i] != '\0' && str[i] != '\0') {
if (TO_UPPER(palavra[i]) == TO_UPPER(str[i])) {
quantidadeDeCaracteresIguais++;
}
i++;
}
return quantidadeDeCaracteresIguais;
}
|
the_stack_data/225144455.c | /*******************************************************************************
*
* DO NOT EDIT THIS FILE!
* This file is auto-generated from the registers file.
* Edits to this file will be lost when it is regenerated.
* Tool: INTERNAL/regs/xgs/generate-pmd.pl
*
* This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file.
*
* Copyright 2007-2020 Broadcom Inc. All rights reserved.
*
* This file provides RXPMD access functions for BCM56980_A0.
*/
#ifdef INCLUDE_PKTIO
#include <pktio_dep.h>
#include <bcmpkt/bcmpkt_rxpmd.h>
#include <bcmpkt/bcmpkt_rxpmd_internal.h>
#include <bcmpkt/bcmpkt_rxpmd_flex_internal.h>
#define MASK(_bn) (((uint32_t)0x1<<(_bn))-1)
#define WORD_FIELD_GET(_d,_s,_l) (((_d) >> (_s)) & MASK(_l))
#define WORD_FIELD_SET(_d,_s,_l,_v) (_d)=(((_d) & ~(MASK(_l) << (_s))) | (((_v) & MASK(_l)) << (_s)))
#define WORD_FIELD_MASK(_d,_s,_l) (_d)=((_d) | (MASK(_l) << (_s)))
/*******************************************************************************
* SWFORMAT: RXPMD
* BLOCKS:
* SIZE: 416
*/
static void bcmpkt_rxpmd_unicast_queue_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_UNICAST_QUEUE with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[4], 24, 1, val);
}
static uint32_t bcmpkt_rxpmd_unicast_queue_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[4], 24, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_UNICAST_QUEUE value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_queue_num_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_QUEUE_NUM with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 22, 6, val);
}
static uint32_t bcmpkt_rxpmd_queue_num_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 22, 6);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_QUEUE_NUM value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_cpu_cos_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_CPU_COS with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 22, 6, val);
}
static uint32_t bcmpkt_rxpmd_cpu_cos_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 22, 6);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_CPU_COS value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_matched_rule_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_MATCHED_RULE with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[8], 3, 8, val);
}
static uint32_t bcmpkt_rxpmd_matched_rule_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[8], 3, 8);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_MATCHED_RULE value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_pkt_length_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_PKT_LENGTH with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[7], 0, 14, val);
}
static uint32_t bcmpkt_rxpmd_pkt_length_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[7], 0, 14);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_PKT_LENGTH value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_src_port_num_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_SRC_PORT_NUM with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[6], 23, 8, val);
}
static uint32_t bcmpkt_rxpmd_src_port_num_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[6], 23, 8);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_SRC_PORT_NUM value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_outer_vid_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_OUTER_VID with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[8], 20, 12, val);
}
static uint32_t bcmpkt_rxpmd_outer_vid_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[8], 20, 12);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_OUTER_VID value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_outer_cfi_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_OUTER_CFI with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[8], 16, 1, val);
}
static uint32_t bcmpkt_rxpmd_outer_cfi_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[8], 16, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_OUTER_CFI value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_outer_pri_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_OUTER_PRI with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[8], 17, 3, val);
}
static uint32_t bcmpkt_rxpmd_outer_pri_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[8], 17, 3);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_OUTER_PRI value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_special_packet_indicator_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_SPECIAL_PACKET_INDICATOR with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[6], 22, 1, val);
}
static uint32_t bcmpkt_rxpmd_special_packet_indicator_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[6], 22, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_SPECIAL_PACKET_INDICATOR value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_special_packet_type_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_SPECIAL_PACKET_TYPE with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[9], 5, 3, val);
}
static uint32_t bcmpkt_rxpmd_special_packet_type_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[9], 5, 3);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_SPECIAL_PACKET_TYPE value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_change_dscp_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_CHANGE_DSCP with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 29, 1, val);
}
static uint32_t bcmpkt_rxpmd_change_dscp_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 29, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_CHANGE_DSCP value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_dscp_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_DSCP with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[9], 5, 6, val);
}
static uint32_t bcmpkt_rxpmd_dscp_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[9], 5, 6);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_DSCP value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_change_ecn_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_CHANGE_ECN with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 30, 1, val);
}
static uint32_t bcmpkt_rxpmd_change_ecn_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 30, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_CHANGE_ECN value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_ecn_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_ECN with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[9], 11, 2, val);
}
static uint32_t bcmpkt_rxpmd_ecn_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[9], 11, 2);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_ECN value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_timestamp_type_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_TIMESTAMP_TYPE with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[4], 16, 2, val);
}
static uint32_t bcmpkt_rxpmd_timestamp_type_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[4], 16, 2);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_TIMESTAMP_TYPE value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_timestamp_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_TIMESTAMP with value %u on device BCM56980_A0.\n"), val));
data[5] = val;
}
static uint32_t bcmpkt_rxpmd_timestamp_get(uint32_t *data)
{
uint32_t val;
return data[5];
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_TIMESTAMP value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_timestamp_hi_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_TIMESTAMP_HI with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[4], 0, 16, val);
}
static uint32_t bcmpkt_rxpmd_timestamp_hi_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[4], 0, 16);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_TIMESTAMP_HI value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_mtp_index_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_MTP_INDEX with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[8], 11, 5, val);
}
static uint32_t bcmpkt_rxpmd_mtp_index_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[8], 11, 5);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_MTP_INDEX value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_bpdu_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_BPDU with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 28, 1, val);
}
static uint32_t bcmpkt_rxpmd_bpdu_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 28, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_BPDU value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_l3only_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_L3ONLY with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[9], 31, 1, val);
}
static uint32_t bcmpkt_rxpmd_l3only_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[9], 31, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_L3ONLY value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_ip_routed_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_IP_ROUTED with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[9], 30, 1, val);
}
static uint32_t bcmpkt_rxpmd_ip_routed_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[9], 30, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_IP_ROUTED value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_uc_sw_copy_dropped_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_UC_SW_COPY_DROPPED with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[4], 23, 1, val);
}
static uint32_t bcmpkt_rxpmd_uc_sw_copy_dropped_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[4], 23, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_UC_SW_COPY_DROPPED value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_switch_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_SWITCH with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[6], 31, 1, val);
}
static uint32_t bcmpkt_rxpmd_switch_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[6], 31, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_SWITCH value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_ing_otag_action_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_ING_OTAG_ACTION with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[9], 28, 2, val);
}
static uint32_t bcmpkt_rxpmd_ing_otag_action_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[9], 28, 2);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_ING_OTAG_ACTION value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_ing_tag_type_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_ING_TAG_TYPE with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[9], 13, 2, val);
}
static uint32_t bcmpkt_rxpmd_ing_tag_type_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[9], 13, 2);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_ING_TAG_TYPE value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_rx_bfd_start_offset_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_RX_BFD_START_OFFSET with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 14, 8, val);
}
static uint32_t bcmpkt_rxpmd_rx_bfd_start_offset_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 14, 8);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_RX_BFD_START_OFFSET value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_rx_bfd_start_offset_type_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_RX_BFD_START_OFFSET_TYPE with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 12, 2, val);
}
static uint32_t bcmpkt_rxpmd_rx_bfd_start_offset_type_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 12, 2);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_RX_BFD_START_OFFSET_TYPE value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_rx_bfd_session_index_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_RX_BFD_SESSION_INDEX with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 0, 12, val);
}
static uint32_t bcmpkt_rxpmd_rx_bfd_session_index_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 0, 12);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_RX_BFD_SESSION_INDEX value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_reason_type_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_REASON_TYPE with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[9], 0, 4, val);
}
static uint32_t bcmpkt_rxpmd_reason_type_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[9], 0, 4);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_REASON_TYPE value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_do_not_change_ttl_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_DO_NOT_CHANGE_TTL with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[9], 4, 1, val);
}
static uint32_t bcmpkt_rxpmd_do_not_change_ttl_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[9], 4, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_DO_NOT_CHANGE_TTL value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_i2e_classid_type_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_I2E_CLASSID_TYPE with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 12, 4, val);
}
static uint32_t bcmpkt_rxpmd_i2e_classid_type_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 12, 4);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_I2E_CLASSID_TYPE value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_i2e_classid_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_I2E_CLASSID with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 0, 12, val);
}
static uint32_t bcmpkt_rxpmd_i2e_classid_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 0, 12);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_I2E_CLASSID value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_ing_l3_intf_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_ING_L3_INTF with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[9], 15, 13, val);
}
static uint32_t bcmpkt_rxpmd_ing_l3_intf_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[9], 15, 13);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_ING_L3_INTF value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_loopback_packet_type_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_LOOPBACK_PACKET_TYPE with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[8], 0, 3, val);
}
static uint32_t bcmpkt_rxpmd_loopback_packet_type_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[8], 0, 3);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_LOOPBACK_PACKET_TYPE value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_regen_crc_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_REGEN_CRC with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[7], 14, 1, val);
}
static uint32_t bcmpkt_rxpmd_regen_crc_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[7], 14, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_REGEN_CRC value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_entropy_label_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_ENTROPY_LABEL with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[6], 2, 20, val);
}
static uint32_t bcmpkt_rxpmd_entropy_label_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[6], 2, 20);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_ENTROPY_LABEL value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_tunnel_decap_type_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_TUNNEL_DECAP_TYPE with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[4], 18, 5, val);
}
static uint32_t bcmpkt_rxpmd_tunnel_decap_type_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[4], 18, 5);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_TUNNEL_DECAP_TYPE value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_dlb_id_valid_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_DLB_ID_VALID with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[12], 31, 1, val);
}
static uint32_t bcmpkt_rxpmd_dlb_id_valid_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[12], 31, 1);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_DLB_ID_VALID value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_dlb_id_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_DLB_ID with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[4], 25, 7, val);
}
static uint32_t bcmpkt_rxpmd_dlb_id_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[4], 25, 7);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_DLB_ID value %u from device BCM56980_A0.\n"), val));
return val;
}
static void bcmpkt_rxpmd_replication_or_nhop_index_set(uint32_t *data, uint32_t val)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Set field BCMPKT_RXPMD_REPLICATION_OR_NHOP_INDEX with value %u on device BCM56980_A0.\n"), val));
WORD_FIELD_SET(data[7], 15, 17, val);
}
static uint32_t bcmpkt_rxpmd_replication_or_nhop_index_get(uint32_t *data)
{
uint32_t val;
val = WORD_FIELD_GET(data[7], 15, 17);
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD,
(BSL_META("Get field BCMPKT_RXPMD_REPLICATION_OR_NHOP_INDEX value %u from device BCM56980_A0.\n"), val));
return val;
}
static uint32_t bcmpkt_rxpmd_i_size_get(uint32_t *data, uint32_t **addr)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD, (BSL_META("Get BCMPKT_RXPMD_I_SIZE on device BCM56980_A0.\n")));
return 13;
}
static uint32_t bcmpkt_rxpmd_i_reason_get(uint32_t *data, uint32_t **addr)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD, (BSL_META("Get field BCMPKT_RXPMD_I_REASON address on device BCM56980_A0.\n")));
*addr = data + 10;
return 2;
}
static uint32_t bcmpkt_rxpmd_i_module_hdr_get(uint32_t *data, uint32_t **addr)
{
LOG_DEBUG(BSL_LS_BCMPKT_RXPMD, (BSL_META("Get field BCMPKT_RXPMD_I_MODULE_HDR address on device BCM56980_A0.\n")));
*addr = data + 0;
return 4;
}
/*******************************************************************************
* SWFORMAT: RX_REASON
* BLOCKS:
* SIZE: 42
*/
void bcm56980_a0_rx_reason_encode(const bcmpkt_rx_reasons_t *reasons, uint32_t *data)
{
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_UVLAN)) {
data[1] |= (0x1 << 0);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_SLF)) {
data[1] |= (0x1 << 1);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_DLF)) {
data[1] |= (0x1 << 2);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_L2MOVE)) {
data[1] |= (0x1 << 3);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_L2CPU)) {
data[1] |= (0x1 << 4);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_L3SRC_MISS)) {
data[1] |= (0x1 << 5);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_L3DST_MISS)) {
data[1] |= (0x1 << 6);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_L3SRC_MOVE)) {
data[1] |= (0x1 << 7);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_MC_MISS)) {
data[1] |= (0x1 << 8);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_IPMC_MISS)) {
data[1] |= (0x1 << 9);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_FFP)) {
data[1] |= (0x1 << 10);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_L3HDR_ERR)) {
data[1] |= (0x1 << 11);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_PROTOCOL_PKT)) {
data[1] |= (0x1 << 12);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_DOS_ATTACK)) {
data[1] |= (0x1 << 13);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_MARTIAN_ADDR)) {
data[1] |= (0x1 << 14);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_TUNNEL_ERR)) {
data[1] |= (0x1 << 15);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_SFLOW_CPU_SFLOW_FLEX)) {
WORD_FIELD_SET(data[1], 16, 2, 1);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_SFLOW_CPU_SFLOW_DST)) {
WORD_FIELD_SET(data[1], 16, 2, 2);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_SFLOW_CPU_SFLOW_SRC)) {
WORD_FIELD_SET(data[1], 16, 2, 3);
}
/*! For mask set ONLY. */
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_SFLOW)) {
WORD_FIELD_SET(data[1], 16, 2, 3);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_ICMP_REDIRECT)) {
data[1] |= (0x1 << 18);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_L3_SLOWPATH)) {
data[1] |= (0x1 << 19);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_PARITY_ERROR)) {
data[1] |= (0x1 << 20);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_L3_MTU_CHECK_FAIL)) {
data[1] |= (0x1 << 21);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_MCIDX_ERROR)) {
data[1] |= (0x1 << 22);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_VFP)) {
data[1] |= (0x1 << 23);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_MPLS_PROC_ERROR_INVALID_PAYLOAD)) {
WORD_FIELD_SET(data[1], 24, 3, 1);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_MPLS_PROC_ERROR_INVALID_ACTION)) {
WORD_FIELD_SET(data[1], 24, 3, 2);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_MPLS_PROC_ERROR_LABEL_MISS)) {
WORD_FIELD_SET(data[1], 24, 3, 3);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_MPLS_PROC_ERROR_TTL_CHECK_FAIL)) {
WORD_FIELD_SET(data[1], 24, 3, 4);
}
/*! For mask set ONLY. */
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_MPLS_PROC_ERROR)) {
WORD_FIELD_SET(data[1], 24, 3, 7);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_PBT_NONUC_PKT)) {
data[1] |= (0x1 << 27);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_L3_NEXT_HOP)) {
data[1] |= (0x1 << 28);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_MY_STATION)) {
data[1] |= (0x1 << 29);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_TIME_SYNC)) {
data[1] |= (0x1 << 30);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_TUNNEL_DECAP_ECN_ERROR)) {
data[1] |= (0x1 << 31);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_BFD_SLOWPATH)) {
data[0] |= (0x1 << 0);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_BFD_ERROR)) {
data[0] |= (0x1 << 1);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_PACKET_TRACE_TO_CPU)) {
data[0] |= (0x1 << 2);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_MPLS_UNKNOWN_CONTROL_PKT)) {
data[0] |= (0x1 << 3);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_MPLS_ALERT_LABEL)) {
data[0] |= (0x1 << 4);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_CPU_IPMC_INTERFACE_MISMATCH)) {
data[0] |= (0x1 << 5);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_DLB_MONITOR)) {
data[0] |= (0x1 << 6);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_INT_TURN_AROUND)) {
data[0] |= (0x1 << 7);
}
if (BCMPKT_RX_REASON_GET(*reasons, BCMPKT_RX_REASON_ETRAP_MONITOR)) {
data[0] |= (0x1 << 8);
}
}
void bcm56980_a0_rx_reason_decode(const uint32_t *data, bcmpkt_rx_reasons_t *reasons)
{
uint32_t val;
COMPILER_REFERENCE(val);
if (data[1] & (0x1 << 0)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_UVLAN);
}
if (data[1] & (0x1 << 1)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_SLF);
}
if (data[1] & (0x1 << 2)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_DLF);
}
if (data[1] & (0x1 << 3)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_L2MOVE);
}
if (data[1] & (0x1 << 4)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_L2CPU);
}
if (data[1] & (0x1 << 5)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_L3SRC_MISS);
}
if (data[1] & (0x1 << 6)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_L3DST_MISS);
}
if (data[1] & (0x1 << 7)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_L3SRC_MOVE);
}
if (data[1] & (0x1 << 8)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_MC_MISS);
}
if (data[1] & (0x1 << 9)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_IPMC_MISS);
}
if (data[1] & (0x1 << 10)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_FFP);
}
if (data[1] & (0x1 << 11)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_L3HDR_ERR);
}
if (data[1] & (0x1 << 12)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_PROTOCOL_PKT);
}
if (data[1] & (0x1 << 13)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_DOS_ATTACK);
}
if (data[1] & (0x1 << 14)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_MARTIAN_ADDR);
}
if (data[1] & (0x1 << 15)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_TUNNEL_ERR);
}
val = WORD_FIELD_GET(data[1], 16, 2);
if (val) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_SFLOW);
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_SFLOW + val);
}
if (data[1] & (0x1 << 18)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_ICMP_REDIRECT);
}
if (data[1] & (0x1 << 19)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_L3_SLOWPATH);
}
if (data[1] & (0x1 << 20)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_PARITY_ERROR);
}
if (data[1] & (0x1 << 21)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_L3_MTU_CHECK_FAIL);
}
if (data[1] & (0x1 << 22)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_MCIDX_ERROR);
}
if (data[1] & (0x1 << 23)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_VFP);
}
val = WORD_FIELD_GET(data[1], 24, 3);
if (val) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_MPLS_PROC_ERROR);
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_MPLS_PROC_ERROR + val);
}
if (data[1] & (0x1 << 27)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_PBT_NONUC_PKT);
}
if (data[1] & (0x1 << 28)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_L3_NEXT_HOP);
}
if (data[1] & (0x1 << 29)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_MY_STATION);
}
if (data[1] & (0x1 << 30)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_TIME_SYNC);
}
if (data[1] & (0x1 << 31)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_TUNNEL_DECAP_ECN_ERROR);
}
if (data[0] & (0x1 << 0)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_BFD_SLOWPATH);
}
if (data[0] & (0x1 << 1)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_BFD_ERROR);
}
if (data[0] & (0x1 << 2)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_PACKET_TRACE_TO_CPU);
}
if (data[0] & (0x1 << 3)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_MPLS_UNKNOWN_CONTROL_PKT);
}
if (data[0] & (0x1 << 4)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_MPLS_ALERT_LABEL);
}
if (data[0] & (0x1 << 5)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_CPU_IPMC_INTERFACE_MISMATCH);
}
if (data[0] & (0x1 << 6)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_DLB_MONITOR);
}
if (data[0] & (0x1 << 7)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_INT_TURN_AROUND);
}
if (data[0] & (0x1 << 8)) {
BCMPKT_RX_REASON_SET(*reasons, BCMPKT_RX_REASON_ETRAP_MONITOR);
}
}
const bcmpkt_rxpmd_fget_t bcm56980_a0_rxpmd_fget = {
{
bcmpkt_rxpmd_unicast_queue_get,
bcmpkt_rxpmd_queue_num_get,
bcmpkt_rxpmd_cpu_cos_get,
NULL,
bcmpkt_rxpmd_matched_rule_get,
bcmpkt_rxpmd_pkt_length_get,
bcmpkt_rxpmd_src_port_num_get,
NULL,
NULL,
NULL,
bcmpkt_rxpmd_outer_vid_get,
bcmpkt_rxpmd_outer_cfi_get,
bcmpkt_rxpmd_outer_pri_get,
bcmpkt_rxpmd_special_packet_indicator_get,
bcmpkt_rxpmd_special_packet_type_get,
bcmpkt_rxpmd_change_dscp_get,
bcmpkt_rxpmd_dscp_get,
bcmpkt_rxpmd_change_ecn_get,
bcmpkt_rxpmd_ecn_get,
bcmpkt_rxpmd_timestamp_type_get,
bcmpkt_rxpmd_timestamp_get,
bcmpkt_rxpmd_timestamp_hi_get,
bcmpkt_rxpmd_mtp_index_get,
bcmpkt_rxpmd_bpdu_get,
NULL,
bcmpkt_rxpmd_l3only_get,
bcmpkt_rxpmd_ip_routed_get,
NULL,
NULL,
bcmpkt_rxpmd_uc_sw_copy_dropped_get,
bcmpkt_rxpmd_switch_get,
NULL,
NULL,
bcmpkt_rxpmd_ing_otag_action_get,
bcmpkt_rxpmd_ing_tag_type_get,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
bcmpkt_rxpmd_rx_bfd_start_offset_get,
bcmpkt_rxpmd_rx_bfd_start_offset_type_get,
bcmpkt_rxpmd_rx_bfd_session_index_get,
bcmpkt_rxpmd_reason_type_get,
bcmpkt_rxpmd_do_not_change_ttl_get,
bcmpkt_rxpmd_i2e_classid_type_get,
bcmpkt_rxpmd_i2e_classid_get,
bcmpkt_rxpmd_ing_l3_intf_get,
bcmpkt_rxpmd_loopback_packet_type_get,
bcmpkt_rxpmd_regen_crc_get,
bcmpkt_rxpmd_entropy_label_get,
bcmpkt_rxpmd_tunnel_decap_type_get,
bcmpkt_rxpmd_dlb_id_valid_get,
bcmpkt_rxpmd_dlb_id_get,
NULL,
NULL,
NULL,
NULL,
bcmpkt_rxpmd_replication_or_nhop_index_get,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL
}
};
const bcmpkt_rxpmd_fset_t bcm56980_a0_rxpmd_fset = {
{
bcmpkt_rxpmd_unicast_queue_set,
bcmpkt_rxpmd_queue_num_set,
bcmpkt_rxpmd_cpu_cos_set,
NULL,
bcmpkt_rxpmd_matched_rule_set,
bcmpkt_rxpmd_pkt_length_set,
bcmpkt_rxpmd_src_port_num_set,
NULL,
NULL,
NULL,
bcmpkt_rxpmd_outer_vid_set,
bcmpkt_rxpmd_outer_cfi_set,
bcmpkt_rxpmd_outer_pri_set,
bcmpkt_rxpmd_special_packet_indicator_set,
bcmpkt_rxpmd_special_packet_type_set,
bcmpkt_rxpmd_change_dscp_set,
bcmpkt_rxpmd_dscp_set,
bcmpkt_rxpmd_change_ecn_set,
bcmpkt_rxpmd_ecn_set,
bcmpkt_rxpmd_timestamp_type_set,
bcmpkt_rxpmd_timestamp_set,
bcmpkt_rxpmd_timestamp_hi_set,
bcmpkt_rxpmd_mtp_index_set,
bcmpkt_rxpmd_bpdu_set,
NULL,
bcmpkt_rxpmd_l3only_set,
bcmpkt_rxpmd_ip_routed_set,
NULL,
NULL,
bcmpkt_rxpmd_uc_sw_copy_dropped_set,
bcmpkt_rxpmd_switch_set,
NULL,
NULL,
bcmpkt_rxpmd_ing_otag_action_set,
bcmpkt_rxpmd_ing_tag_type_set,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
bcmpkt_rxpmd_rx_bfd_start_offset_set,
bcmpkt_rxpmd_rx_bfd_start_offset_type_set,
bcmpkt_rxpmd_rx_bfd_session_index_set,
bcmpkt_rxpmd_reason_type_set,
bcmpkt_rxpmd_do_not_change_ttl_set,
bcmpkt_rxpmd_i2e_classid_type_set,
bcmpkt_rxpmd_i2e_classid_set,
bcmpkt_rxpmd_ing_l3_intf_set,
bcmpkt_rxpmd_loopback_packet_type_set,
bcmpkt_rxpmd_regen_crc_set,
bcmpkt_rxpmd_entropy_label_set,
bcmpkt_rxpmd_tunnel_decap_type_set,
bcmpkt_rxpmd_dlb_id_valid_set,
bcmpkt_rxpmd_dlb_id_set,
NULL,
NULL,
NULL,
NULL,
bcmpkt_rxpmd_replication_or_nhop_index_set,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL
}
};
const bcmpkt_rxpmd_figet_t bcm56980_a0_rxpmd_figet = {
{
bcmpkt_rxpmd_i_size_get,
bcmpkt_rxpmd_i_reason_get,
bcmpkt_rxpmd_i_module_hdr_get,
NULL
}
};
const bcmpkt_rxpmd_flex_fget_t bcm56980_a0_rxpmd_flex_fget = {
{
NULL
}
};
const bcmpkt_rxpmd_flex_fset_t bcm56980_a0_rxpmd_flex_fset = {
{
NULL
}
};
const bcmpkt_rxpmd_flex_figet_t bcm56980_a0_rxpmd_flex_figet = {
{
NULL
}
};
void bcm56980_a0_rxpmd_flex_reason_encode(const bcmpkt_rxpmd_flex_reasons_t *reasons, uint32_t *data)
{
}
void bcm56980_a0_rxpmd_flex_reason_decode(const uint32_t *data, bcmpkt_rxpmd_flex_reasons_t *reasons)
{
}
void bcm56980_a0_rxpmd_flex_view_info_get(bcmpkt_pmd_view_info_t *info)
{
}
static shr_enum_map_t bcm56980_a0_rxpmd_view_types[] = {
{NULL, -1},
};
/* -2: unsupported, -1: global, others: view's value */
static int bcm56980_a0_rxpmd_view_infos[BCMPKT_RXPMD_FID_COUNT] = {
-1, -1, -1, -2, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -2, -2, -1, -1, -2,
-2, -1, -1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -2,
-2, -1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
};
void bcm56980_a0_rxpmd_view_info_get(bcmpkt_pmd_view_info_t *info)
{
info->view_infos = bcm56980_a0_rxpmd_view_infos;
info->view_types = bcm56980_a0_rxpmd_view_types;
info->view_type_get = NULL;
}
#endif /* INCLUDE_PKTIO */
|
the_stack_data/145363.c | /*WRITE A C PROGRAM TO FIND FACTORIAL OF A NUMBER.
Sample Input : 6
Sample Output : 720
Hint -> The factorial is calculated as follows :
6! = 6*5*4*3*2*1 = 720*/
#include<stdio.h>
void main()
{
int n,i,f=1;
printf("TO FIND FACTORIAL OF A NUMBER.....");
printf("\nEnter any number: ");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
f=f*i;
}
printf("The factorial of %d number is %d",n,f);
}
|
the_stack_data/620379.c | /* { dg-do compile } */
/* { dg-options "-O1 -fno-trapping-math -fdump-tree-gimple -fdump-tree-optimized" } */
/* LLVM LOCAL test not applicable */
/* { dg-require-fdump "" } */
extern void f(int);
extern void link_error ();
extern float x;
extern double y;
extern long double z;
int
main ()
{
double nan = __builtin_nan ("");
float nanf = __builtin_nanf ("");
long double nanl = __builtin_nanl ("");
if (!__builtin_isnan (nan))
link_error ();
if (!__builtin_isnan (nanf))
link_error ();
if (!__builtin_isnanf (nanf))
link_error ();
if (!__builtin_isnan (nanl))
link_error ();
if (!__builtin_isnanl (nanl))
link_error ();
if (__builtin_isnan (4.0))
link_error ();
if (__builtin_isnan (4.0))
link_error ();
if (__builtin_isnanf (4.0))
link_error ();
if (__builtin_isnan (4.0))
link_error ();
if (__builtin_isnanl (4.0))
link_error ();
f (__builtin_isnan (x));
f (__builtin_isnan (y));
f (__builtin_isnanf (y));
f (__builtin_isnan (z));
f (__builtin_isnanl (z));
}
/* Check that all instances of __builtin_isnan were folded. */
/* { dg-final { scan-tree-dump-times "isnan" 0 "gimple" } } */
/* { dg-final { cleanup-tree-dump "gimple" } } */
/* Check that all instances of link_error were subject to DCE. */
/* { dg-final { scan-tree-dump-times "link_error" 0 "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
|
the_stack_data/88981.c | #define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int child(void *args)
{
printf("pid as seen in the child: %d\n", getpid());
system("bash");
}
int main()
{
int namespaces = CLONE_NEWUTS|CLONE_NEWPID|CLONE_NEWIPC|CLONE_NEWNS|CLONE_NEWNET;
pid_t p = clone(child, malloc(4096) + 4096, SIGCHLD|namespaces, NULL);
if (p == -1) {
perror("clone");
exit(1);
}
printf("child pid: %d./na \n", p);
waitpid(p, NULL, 0);
return 0;
} |
the_stack_data/108334.c | /*function returning address
*/
#include <stdio.h>
//function declaration
char *funChar(char *, char *);
int *funInt(int *, int *);
int main(){
//variable declaration
char ch1, ch2;
int i1, i2;
//pointer variable declaration
char *cptr;
int *iptr;
//variable initialization
ch1 = 'a', ch2 = 'b';
i1 = 10, i2 = 20;
//calling function and printing bigger value
cptr = funChar(&ch1, &ch2); //sending address
printf("%c\n", *cptr); //printing value at the address
iptr = funInt(&i1, &i2);
printf("%d\n", *iptr);
return 0;
}
//function definition
char *funChar(char *x, char *y){
if(*x > *y)
return x; //return address stored in x
else if(*y > *x)
return y; //return address stored in y
return x; //same value so return any one
}
int *funInt(int *x, int *y){
if(*x > *y)
return x; //return address stored in x
else if(*y > *x)
return y; //return address stored in y
return x; //same value so return any one
} |
the_stack_data/173577798.c | /*
** talker.c -- a datagram "client" demo
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#define SERVERPORT "4950" // the port users will be connecting to
int main(int argc, char *argv[])
{
int sockfd;
struct addrinfo hints, *servinfo, *p;
int rv;
int numbytes;
if (argc != 3) {
fprintf(stderr,"usage: talker hostname message\n");
exit(1);
}
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
if ((rv = getaddrinfo(argv[1], SERVERPORT, &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
// loop through all the results and make a socket
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror("talker: socket");
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, "talker: failed to create socket\n");
return 2;
}
if ((numbytes = sendto(sockfd, argv[2], strlen(argv[2]), 0,
p->ai_addr, p->ai_addrlen)) == -1) {
perror("talker: sendto");
exit(1);
}
freeaddrinfo(servinfo);
printf("talker: sent %d bytes to %s\n", numbytes, argv[1]);
close(sockfd);
return 0;
}
|
the_stack_data/25137159.c | #include <stdio.h>
/* copia la entrada a la salida; 2a. versiC3n */
main () {
int c;
while ((c=getchar())!=EOF)
putchar (c);
}
|
the_stack_data/86075343.c | #include <stdio.h>
int main() {
printf("hello\n");
return 0;
}
|
the_stack_data/153268043.c | // Casting function pointers to an extent where we might hit undefined
// behaviour? Anyways ... still worx with RaceHog :)
#include <pthread.h>
#include <stdlib.h>
static int race;
static void
f123(int* i) {
*i = 123; // Data race.
}
static void
f312(int* i) {
*i = 312; // Data race.
}
static void
apply(void (*fn)(int* i)) {
(void) fn(&race);
}
static void*
thread(void* arg) {
// void* -> void (*)(int*)
void (*fn)(int*) = (void (*)(int*))arg;
(void) apply(fn);
return NULL;
}
int
main(void) {
pthread_t t;
// void (*)(int*) -> void*
(void) pthread_create(&t, NULL, thread, f123);
void (*my312)(void*) = (void (*)(void*))&f312;
// Oops, I think I have misread the manual of `f312` ... however, someone
// suggested to simply put a cast in there (that seems to be _the_ magic
// bullet when programming C):
// void (*)(void*) -> void (*)(int*)
(void) apply((void (*)(int*)) my312); // Phew, it works now! :)
(void) pthread_join(t, NULL);
return EXIT_SUCCESS;
}
|
the_stack_data/248581534.c | #include <math.h>
#include <stdio.h>
/* Copyright 2021 Melwyn Francis Carlo */
# define INFINITY_NUM 999.0
# define TOLERANCE 1.0E7
int main()
{
const int square_grid_dimensions = 50;
int n = 0;
for (int i1 = 1; i1 < square_grid_dimensions; i1++)
{
for (int j1 = 1; j1 < square_grid_dimensions; j1++)
{
for (int i2 = (i1 + 1); i2 < square_grid_dimensions; i2++)
{
for (int j2 = 1; j2 < j1; j2++)
{//printf("%d, %d & %d, %d : ", i1, j1, i2, j2);
//if ((i2 < i1))
// continue;
if ((i2 == 0) || (j1 == 0))
continue;
if ((i1 == 0) && ((j2 == 0) || (j2 == j1)))
continue;
if ((j2 == 0) && (i2 == i1))
continue;
/*if ((i2 < i1) && (j2 >= j1))
continue;*/
if ((i1 == 0) && (i2 == 0))
continue;
if ((j1 == 0) && (j2 == 0))
continue;
double slope1 = (double) i1;
double slope2 = (double)(i2 - i1);
double slope3 = (double) i2;
if (slope1 == 0.0)
continue;
else
slope1 = (int)(((double)j1 / (double)slope1) * TOLERANCE) / TOLERANCE;
if (slope2 == 0.0)
continue;
else
slope2 = (int)(((double)(j2 - j1) / (double)slope2) * TOLERANCE) / TOLERANCE;
if (slope3 == 0.0)
continue;
else
slope3 = (int)(((double)j2 / (double)slope3) * TOLERANCE) / TOLERANCE;
if ((i2 <= i1) && (j2 >= (i2 * slope1)))
continue;
if (slope1 == 0.0)
continue;
if (slope2 == 0.0)
continue;
if (slope3 == 0.0)
continue;
if ((slope1 == slope2) || (slope2 == slope3) || (slope1 == slope3))
continue;
double slope12 = slope1 * slope2;
double slope23 = slope2 * slope3;
double slope13 = slope1 * slope3;
if ( (((slope12) < 0.0) && ((int)(fabs(slope12) * TOLERANCE) / TOLERANCE) == 1.0)
|| (((slope23) < 0.0) && ((int)(fabs(slope23) * TOLERANCE) / TOLERANCE) == 1.0)
|| (((slope13) < 0.0) && ((int)(fabs(slope13) * TOLERANCE) / TOLERANCE) == 1.0) ){printf("4. %d, %d & %d, %d = %lf\n", i1, j1, i2, j2, slope1);
n++;}
}
}
}
}
// 2742
printf("%d\n", n);
return 0;
}
|
the_stack_data/9842.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#ifdef _OPENACC
#include <openacc.h>
#endif
/* Utility routine for allocating a two dimensional array */
double **malloc_2d(int nx, int ny)
{
double **array;
int i;
array = (double **) malloc(nx * sizeof(double *));
array[0] = (double *) malloc(nx * ny * sizeof(double));
for (i = 1; i < nx; i++) {
array[i] = array[0] + i * ny;
}
return array;
}
/* Utility routine for deallocating a two dimensional array */
void free_2d(double **array)
{
free(array[0]);
free(array);
}
void init(double ** arr, int nx, int ny)
{
int i, j;
for (i = 0; i < nx + 2; i++)
for (j = 0; j < ny + 2; j++)
arr[i][j] = 0e0;
for (i = 0; i < nx + 2; i++)
arr[i][ny+1] = 1e0;
for (i = 0; i < ny+2; i++)
arr[nx+1][i] = 1e0;
}
int main(int argc, char **argv)
{
double eps;
double ** u, ** unew;
const double factor = 0.25;
const int niter = 2;
double mlups = 0e0;
int nx = 1022, ny = 1022;
clock_t t_start, t_end;
double dt;
double sum;
int i, j;
int iter;
u = malloc_2d(nx+2, ny+2);
unew = malloc_2d(nx+2, ny+2);
init(u, nx, ny);
init(unew, nx, ny);
t_start = clock();
/* TODO: Parallelize this */
for (iter = 0; iter < niter; iter++) {
#pragma acc parallel
{
#pragma acc loop
for (i = 1; i < nx + 1; i++)
#pragma acc loop
for (j = 1; j < ny + 1; j++) {
unew[i][j] = factor * (u[i-1][j] + u[i+1][j] +
u[i][j-1] + u[i][j+1]);
}
}
#pragma acc parallel
{
#pragma acc loop
for (i = 1; i < nx + 1; i++)
#pragma acc loop
for (j = 1; j < ny + 1; j++) {
u[i][j] = factor * (unew[i-1][j] + unew[i+1][j] +
unew[i][j-1] + unew[i][j+1]);
}
}
}
/* Compute a reference sum, do not parallelize this! */
sum = 0.0;
for (i = 1; i < nx + 1; i++)
for (j = 1; j < ny + 1; j++)
sum += u[i][j];
free_2d(u);
free_2d(unew);
mlups = niter * nx * ny * 1.0e-6;
t_end = clock();
dt = ((double)(t_end-t_start)) / CLOCKS_PER_SEC;
printf("Stencil: Time =%18.16f sec, MLups/s=%18.16f, sum=%18.16f\n",dt, (double) mlups/dt, sum);
return 0;
}
|
the_stack_data/117278.c | #ifdef __cplusplus
extern "C" {
#endif
//===============================================================================================================================================================================================================200
// TIMER CODE
//===============================================================================================================================================================================================================200
//======================================================================================================================================================150
// INCLUDE/DEFINE
//======================================================================================================================================================150
#include <stdlib.h>
//======================================================================================================================================================150
// FUNCTIONS
//======================================================================================================================================================150
//====================================================================================================100
// DISPLAY TIME
//====================================================================================================100
// Returns the current system time in microseconds
long long get_time() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (tv.tv_sec * 1000000) + tv.tv_usec;
}
//===============================================================================================================================================================================================================200
// END TIMER CODE
//===============================================================================================================================================================================================================200
#ifdef __cplusplus
}
#endif
|
the_stack_data/7949472.c | #include <stdio.h>
struct {
struct {
int edg, val, fa;
} N[16009];
struct {
int dst, nxt;
} E[32009];
int Ec;
int n;
} T;
void t_ini(int n)
{
T.n = n;
T.Ec = 1;
}
void t_add(int u, int v)
{
T.E[T.Ec].dst = v;
T.E[T.Ec].nxt = T.N[u].edg;
T.N[u].edg = T.Ec++;
}
void t_add2(int u, int v)
{
t_add(u, v);
t_add(v, u);
}
int f[16009];
void t_dfs(int rt)
{
int i;
f[rt] = T.N[rt].val;
for (i = T.N[rt].edg; i; i = T.E[i].nxt)
if (T.E[i].dst != T.N[rt].fa) {
T.N[T.E[i].dst].fa = rt;
t_dfs(T.E[i].dst);
if (f[T.E[i].dst] >= 0)
f[rt] += f[T.E[i].dst];
}
}
int main(void)
{
int n;
int i;
int ans = 0;
#ifdef DEBUG
freopen("in", "r", stdin);
#endif
scanf("%d", &n);
for (i = 1; i <= n; ++i)
scanf("%d", &T.N[i].val);
t_ini(n);
for (i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
t_add2(u, v);
}
t_dfs(1);
for (i = 1; i <= n; ++i)
if (f[i] > ans)
ans = f[i];
printf("%d\n", ans);
return 0;
}
|
the_stack_data/51945.c | /**
******************************************************************************
* @file stm32g0xx_ll_lptim.c
* @author MCD Application Team
* @brief LPTIM LL module driver.
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2018 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
#if defined(USE_FULL_LL_DRIVER)
/* Includes ------------------------------------------------------------------*/
#include "stm32g0xx_ll_lptim.h"
#include "stm32g0xx_ll_bus.h"
#include "stm32g0xx_ll_rcc.h"
#ifdef USE_FULL_ASSERT
#include "stm32_assert.h"
#else
#define assert_param(expr) ((void)0U)
#endif
/** @addtogroup STM32G0xx_LL_Driver
* @{
*/
#if defined (LPTIM1) || defined (LPTIM2)
/** @addtogroup LPTIM_LL
* @{
*/
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/** @addtogroup LPTIM_LL_Private_Macros
* @{
*/
#define IS_LL_LPTIM_CLOCK_SOURCE(__VALUE__) (((__VALUE__) == LL_LPTIM_CLK_SOURCE_INTERNAL) \
|| ((__VALUE__) == LL_LPTIM_CLK_SOURCE_EXTERNAL))
#define IS_LL_LPTIM_CLOCK_PRESCALER(__VALUE__) (((__VALUE__) == LL_LPTIM_PRESCALER_DIV1) \
|| ((__VALUE__) == LL_LPTIM_PRESCALER_DIV2) \
|| ((__VALUE__) == LL_LPTIM_PRESCALER_DIV4) \
|| ((__VALUE__) == LL_LPTIM_PRESCALER_DIV8) \
|| ((__VALUE__) == LL_LPTIM_PRESCALER_DIV16) \
|| ((__VALUE__) == LL_LPTIM_PRESCALER_DIV32) \
|| ((__VALUE__) == LL_LPTIM_PRESCALER_DIV64) \
|| ((__VALUE__) == LL_LPTIM_PRESCALER_DIV128))
#define IS_LL_LPTIM_WAVEFORM(__VALUE__) (((__VALUE__) == LL_LPTIM_OUTPUT_WAVEFORM_PWM) \
|| ((__VALUE__) == LL_LPTIM_OUTPUT_WAVEFORM_SETONCE))
#define IS_LL_LPTIM_OUTPUT_POLARITY(__VALUE__) (((__VALUE__) == LL_LPTIM_OUTPUT_POLARITY_REGULAR) \
|| ((__VALUE__) == LL_LPTIM_OUTPUT_POLARITY_INVERSE))
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/** @defgroup LPTIM_Private_Functions LPTIM Private Functions
* @{
*/
/**
* @}
*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup LPTIM_LL_Exported_Functions
* @{
*/
/** @addtogroup LPTIM_LL_EF_Init
* @{
*/
/**
* @brief Set LPTIMx registers to their reset values.
* @param LPTIMx LP Timer instance
* @retval An ErrorStatus enumeration value:
* - SUCCESS: LPTIMx registers are de-initialized
* - ERROR: invalid LPTIMx instance
*/
ErrorStatus LL_LPTIM_DeInit(LPTIM_TypeDef *LPTIMx)
{
ErrorStatus result = SUCCESS;
/* Check the parameters */
assert_param(IS_LPTIM_INSTANCE(LPTIMx));
if (LPTIMx == LPTIM1)
{
LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_LPTIM1);
LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_LPTIM1);
}
#if defined(LPTIM2)
else if (LPTIMx == LPTIM2)
{
LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_LPTIM2);
LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_LPTIM2);
}
#endif /* LPTIM2 */
else
{
result = ERROR;
}
return result;
}
/**
* @brief Set each fields of the LPTIM_InitStruct structure to its default
* value.
* @param LPTIM_InitStruct pointer to a @ref LL_LPTIM_InitTypeDef structure
* @retval None
*/
void LL_LPTIM_StructInit(LL_LPTIM_InitTypeDef *LPTIM_InitStruct)
{
/* Set the default configuration */
LPTIM_InitStruct->ClockSource = LL_LPTIM_CLK_SOURCE_INTERNAL;
LPTIM_InitStruct->Prescaler = LL_LPTIM_PRESCALER_DIV1;
LPTIM_InitStruct->Waveform = LL_LPTIM_OUTPUT_WAVEFORM_PWM;
LPTIM_InitStruct->Polarity = LL_LPTIM_OUTPUT_POLARITY_REGULAR;
}
/**
* @brief Configure the LPTIMx peripheral according to the specified parameters.
* @note LL_LPTIM_Init can only be called when the LPTIM instance is disabled.
* @note LPTIMx can be disabled using unitary function @ref LL_LPTIM_Disable().
* @param LPTIMx LP Timer Instance
* @param LPTIM_InitStruct pointer to a @ref LL_LPTIM_InitTypeDef structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: LPTIMx instance has been initialized
* - ERROR: LPTIMx instance hasn't been initialized
*/
ErrorStatus LL_LPTIM_Init(LPTIM_TypeDef *LPTIMx, LL_LPTIM_InitTypeDef *LPTIM_InitStruct)
{
ErrorStatus result = SUCCESS;
/* Check the parameters */
assert_param(IS_LPTIM_INSTANCE(LPTIMx));
assert_param(IS_LL_LPTIM_CLOCK_SOURCE(LPTIM_InitStruct->ClockSource));
assert_param(IS_LL_LPTIM_CLOCK_PRESCALER(LPTIM_InitStruct->Prescaler));
assert_param(IS_LL_LPTIM_WAVEFORM(LPTIM_InitStruct->Waveform));
assert_param(IS_LL_LPTIM_OUTPUT_POLARITY(LPTIM_InitStruct->Polarity));
/* The LPTIMx_CFGR register must only be modified when the LPTIM is disabled
(ENABLE bit is reset to 0).
*/
if (LL_LPTIM_IsEnabled(LPTIMx) == 1UL)
{
result = ERROR;
}
else
{
/* Set CKSEL bitfield according to ClockSource value */
/* Set PRESC bitfield according to Prescaler value */
/* Set WAVE bitfield according to Waveform value */
/* Set WAVEPOL bitfield according to Polarity value */
MODIFY_REG(LPTIMx->CFGR,
(LPTIM_CFGR_CKSEL | LPTIM_CFGR_PRESC | LPTIM_CFGR_WAVE | LPTIM_CFGR_WAVPOL),
LPTIM_InitStruct->ClockSource | \
LPTIM_InitStruct->Prescaler | \
LPTIM_InitStruct->Waveform | \
LPTIM_InitStruct->Polarity);
}
return result;
}
/**
* @brief Disable the LPTIM instance
* @rmtoll CR ENABLE LL_LPTIM_Disable
* @param LPTIMx Low-Power Timer instance
* @note The following sequence is required to solve LPTIM disable HW limitation.
* Please check Errata Sheet ES0335 for more details under "MCU may remain
* stuck in LPTIM interrupt when entering Stop mode" section.
* @retval None
*/
void LL_LPTIM_Disable(LPTIM_TypeDef *LPTIMx)
{
LL_RCC_ClocksTypeDef rcc_clock;
uint32_t tmpclksource = 0;
uint32_t tmpIER;
uint32_t tmpCFGR;
uint32_t tmpCMP;
uint32_t tmpARR;
uint32_t tmpCFGR2;
/* Check the parameters */
assert_param(IS_LPTIM_INSTANCE(LPTIMx));
__disable_irq();
/********** Save LPTIM Config *********/
/* Save LPTIM source clock */
switch ((uint32_t)LPTIMx)
{
case LPTIM1_BASE:
tmpclksource = LL_RCC_GetLPTIMClockSource(LL_RCC_LPTIM1_CLKSOURCE);
break;
#if defined(LPTIM2)
case LPTIM2_BASE:
tmpclksource = LL_RCC_GetLPTIMClockSource(LL_RCC_LPTIM2_CLKSOURCE);
break;
#endif /* LPTIM2 */
default:
break;
}
/* Save LPTIM configuration registers */
tmpIER = LPTIMx->IER;
tmpCFGR = LPTIMx->CFGR;
tmpCMP = LPTIMx->CMP;
tmpARR = LPTIMx->ARR;
tmpCFGR2 = LPTIMx->CFGR2;
/************* Reset LPTIM ************/
(void)LL_LPTIM_DeInit(LPTIMx);
/********* Restore LPTIM Config *******/
LL_RCC_GetSystemClocksFreq(&rcc_clock);
if ((tmpCMP != 0UL) || (tmpARR != 0UL))
{
/* Force LPTIM source kernel clock from APB */
switch ((uint32_t)LPTIMx)
{
case LPTIM1_BASE:
LL_RCC_SetLPTIMClockSource(LL_RCC_LPTIM1_CLKSOURCE_PCLK1);
break;
#if defined(LPTIM2)
case LPTIM2_BASE:
LL_RCC_SetLPTIMClockSource(LL_RCC_LPTIM2_CLKSOURCE_PCLK1);
break;
#endif /* LPTIM2 */
default:
break;
}
if (tmpCMP != 0UL)
{
/* Restore CMP and ARR registers (LPTIM should be enabled first) */
LPTIMx->CR |= LPTIM_CR_ENABLE;
LPTIMx->CMP = tmpCMP;
/* Polling on CMP write ok status after above restore operation */
do
{
rcc_clock.SYSCLK_Frequency--; /* Used for timeout */
}
while (((LL_LPTIM_IsActiveFlag_CMPOK(LPTIMx) != 1UL)) && ((rcc_clock.SYSCLK_Frequency) > 0UL));
LL_LPTIM_ClearFlag_CMPOK(LPTIMx);
}
if (tmpARR != 0UL)
{
LPTIMx->CR |= LPTIM_CR_ENABLE;
LPTIMx->ARR = tmpARR;
LL_RCC_GetSystemClocksFreq(&rcc_clock);
/* Polling on ARR write ok status after above restore operation */
do
{
rcc_clock.SYSCLK_Frequency--; /* Used for timeout */
}
while (((LL_LPTIM_IsActiveFlag_ARROK(LPTIMx) != 1UL)) && ((rcc_clock.SYSCLK_Frequency) > 0UL));
LL_LPTIM_ClearFlag_ARROK(LPTIMx);
}
/* Restore LPTIM source kernel clock */
LL_RCC_SetLPTIMClockSource(tmpclksource);
}
/* Restore configuration registers (LPTIM should be disabled first) */
LPTIMx->CR &= ~(LPTIM_CR_ENABLE);
LPTIMx->IER = tmpIER;
LPTIMx->CFGR = tmpCFGR;
LPTIMx->CFGR2 = tmpCFGR2;
__enable_irq();
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#endif /* LPTIM1 || LPTIM2 */
/**
* @}
*/
#endif /* USE_FULL_LL_DRIVER */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/40762047.c | #include<stdio.h>
int main()
{
int i,j,a=0,s=0,n,b;
printf("Series- \nS = 1 + ( 1 + 2) + (1+2+3)+............+(1+2+3+4+.....+20)");
printf("\nEnter the no of Terms ");
scanf("%d",&n);
printf("\n The Terms are:-\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=i;j++)
{
b=j;
s+=b;
}
printf("%d\n",s);
a+=s;
s=0;
}
printf("\nSum is S= %d",a);
return 0;
}
|
the_stack_data/23574485.c | #include <signal.h>
#include "syscall.h"
int sigsuspend(const sigset_t *mask)
{
int ret,retval;
sigset_t oldset;
retval = sigprocmask(SIG_BLOCK, 0, &oldset);
if (retval != 0){
return retval;
}
ret = syscall_cp(SYS_rt_sigsuspend, mask, _NSIG/8);
if (ret == -1){
retval = sigprocmask(SIG_SETMASK, &oldset, 0);
if (retval != 0){
return retval;
}
}
return ret;
} |
the_stack_data/39307.c | // RUN: %clang_cc1 -no-opaque-pointers -w -fblocks -triple i386-apple-darwin9 -emit-llvm -o %t %s
// RUN: FileCheck < %t %s
// CHECK-LABEL: define{{.*}} void @f0(%struct.s0* noundef byval(%struct.s0) align 4 %0)
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %{{.*}}, i8* align 4 %{{.*}}, i32 16, i1 false)
// CHECK: }
struct s0 { long double a; };
void f0(struct s0 a0) {
extern long double f0_g0;
f0_g0 = a0.a;
}
|
the_stack_data/1188767.c | int main(int argc, char** argv) {
return 0;
}
|
the_stack_data/596554.c | #include <stdio.h>
#include <ctype.h>
void main()
{
char c;
printf("\nEnter any Key on Your Keyboard\n");
c = getchar();
if (isalpha(c) > 0)
{
printf("\nYou have Entered an Alphabet");
}
else if (isdigit(c) > 0)
{
printf("\nYou Have Entered a Digit");
}
else
{
printf("\nYou did not Enter any Alphanumeric Character");
}
}
|
the_stack_data/232954763.c | #include <stdio.h>
int main (){
// Solved using "/bin/echo -n"
const char * command = "echo -n 'Hello World'";
FILE * stream = popen(command, "r");
if (!stream) {
printf("error: popen(%s) returned %p\n", command, stream);
}
else{
char buffer[1024+1] = {0};
while (!feof(stream)){
if (fgets(buffer, 1024, stream) != NULL){
printf("%s", buffer);
}
}
pclose(stream);
stream = NULL;
}
return 0;
}
|
the_stack_data/90763593.c | #include<stdio.h>
int main(){
int row;
printf("Enter no. of rows: ");
scanf("%d", &row);
for(int i=1; i<=row; i++){
for(int j=1; j<=5; j++){
if(i==1||i==row){
printf("*");
}
else if(i>1&&i<row){
if(j>1&&j<5){
if(i%2==0){
if(j==2||j==4){
printf("!");
}
else{
printf(" ");
}
}
else if(i%2!=0){
if(j==3){
printf("!");
}
else{
printf(" ");
}
}
}
else
printf("*");
}
}
printf("\n");
}
return 0;
} |
Subsets and Splits