1
2
3
4#line 19 "include/asm-generic/int-ll64.h"
5typedef signed char __s8;
6#line 22 "include/asm-generic/int-ll64.h"
7typedef short __s16;
8#line 23 "include/asm-generic/int-ll64.h"
9typedef unsigned short __u16;
10#line 25 "include/asm-generic/int-ll64.h"
11typedef int __s32;
12#line 26 "include/asm-generic/int-ll64.h"
13typedef unsigned int __u32;
14#line 30 "include/asm-generic/int-ll64.h"
15typedef unsigned long long __u64;
16#line 43 "include/asm-generic/int-ll64.h"
17typedef unsigned char u8;
18#line 45 "include/asm-generic/int-ll64.h"
19typedef short s16;
20#line 46 "include/asm-generic/int-ll64.h"
21typedef unsigned short u16;
22#line 48 "include/asm-generic/int-ll64.h"
23typedef int s32;
24#line 49 "include/asm-generic/int-ll64.h"
25typedef unsigned int u32;
26#line 51 "include/asm-generic/int-ll64.h"
27typedef long long s64;
28#line 52 "include/asm-generic/int-ll64.h"
29typedef unsigned long long u64;
30#line 14 "include/asm-generic/posix_types.h"
31typedef long __kernel_long_t;
32#line 15 "include/asm-generic/posix_types.h"
33typedef unsigned long __kernel_ulong_t;
34#line 52 "include/asm-generic/posix_types.h"
35typedef unsigned int __kernel_uid32_t;
36#line 53 "include/asm-generic/posix_types.h"
37typedef unsigned int __kernel_gid32_t;
38#line 75 "include/asm-generic/posix_types.h"
39typedef __kernel_ulong_t __kernel_size_t;
40#line 76 "include/asm-generic/posix_types.h"
41typedef __kernel_long_t __kernel_ssize_t;
42#line 91 "include/asm-generic/posix_types.h"
43typedef long long __kernel_loff_t;
44#line 92 "include/asm-generic/posix_types.h"
45typedef __kernel_long_t __kernel_time_t;
46#line 95 "include/asm-generic/posix_types.h"
47typedef int __kernel_clockid_t;
48#line 21 "include/linux/types.h"
49typedef __u32 __kernel_dev_t;
50#line 24 "include/linux/types.h"
51typedef __kernel_dev_t dev_t;
52#line 27 "include/linux/types.h"
53typedef unsigned short umode_t;
54#line 35 "include/linux/types.h"
55typedef __kernel_clockid_t clockid_t;
56#line 38 "include/linux/types.h"
57typedef _Bool bool;
58#line 40 "include/linux/types.h"
59typedef __kernel_uid32_t uid_t;
60#line 41 "include/linux/types.h"
61typedef __kernel_gid32_t gid_t;
62#line 54 "include/linux/types.h"
63typedef __kernel_loff_t loff_t;
64#line 63 "include/linux/types.h"
65typedef __kernel_size_t size_t;
66#line 68 "include/linux/types.h"
67typedef __kernel_ssize_t ssize_t;
68#line 78 "include/linux/types.h"
69typedef __kernel_time_t time_t;
70#line 142 "include/linux/types.h"
71typedef unsigned long sector_t;
72#line 143 "include/linux/types.h"
73typedef unsigned long blkcnt_t;
74#line 202 "include/linux/types.h"
75typedef unsigned int gfp_t;
76#line 203 "include/linux/types.h"
77typedef unsigned int fmode_t;
78#line 206 "include/linux/types.h"
79typedef u64 phys_addr_t;
80#line 211 "include/linux/types.h"
81typedef phys_addr_t resource_size_t;
82#line 219 "include/linux/types.h"
83struct __anonstruct_atomic_t_7 {
84 int counter ;
85};
86#line 219 "include/linux/types.h"
87typedef struct __anonstruct_atomic_t_7 atomic_t;
88#line 224 "include/linux/types.h"
89struct __anonstruct_atomic64_t_8 {
90 long counter ;
91};
92#line 224 "include/linux/types.h"
93typedef struct __anonstruct_atomic64_t_8 atomic64_t;
94#line 229 "include/linux/types.h"
95struct list_head {
96 struct list_head *next ;
97 struct list_head *prev ;
98};
99#line 233
100struct hlist_node;
101#line 233 "include/linux/types.h"
102struct hlist_head {
103 struct hlist_node *first ;
104};
105#line 237 "include/linux/types.h"
106struct hlist_node {
107 struct hlist_node *next ;
108 struct hlist_node **pprev ;
109};
110#line 253 "include/linux/types.h"
111struct rcu_head {
112 struct rcu_head *next ;
113 void (*func)(struct rcu_head *head ) ;
114};
115#line 146 "include/linux/init.h"
116typedef void (*ctor_fn_t)(void);
117#line 56 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/alternative.h"
118struct module;
119#line 56
120struct module;
121#line 47 "include/linux/dynamic_debug.h"
122struct device;
123#line 47
124struct device;
125#line 135 "include/linux/kernel.h"
126struct completion;
127#line 135
128struct completion;
129#line 349
130struct pid;
131#line 349
132struct pid;
133#line 12 "include/linux/thread_info.h"
134struct timespec;
135#line 12
136struct timespec;
137#line 18 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/page.h"
138struct page;
139#line 18
140struct page;
141#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/thread_info.h"
142struct task_struct;
143#line 20
144struct task_struct;
145#line 7 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/processor.h"
146struct task_struct;
147#line 295 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/pgtable_types.h"
148struct file;
149#line 295
150struct file;
151#line 313
152struct seq_file;
153#line 313
154struct seq_file;
155#line 46 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/paravirt_types.h"
156struct page;
157#line 52
158struct task_struct;
159#line 329
160struct arch_spinlock;
161#line 329
162struct arch_spinlock;
163#line 139 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/ptrace.h"
164struct task_struct;
165#line 8 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/current.h"
166struct task_struct;
167#line 10 "include/asm-generic/bug.h"
168struct bug_entry {
169 int bug_addr_disp ;
170 int file_disp ;
171 unsigned short line ;
172 unsigned short flags ;
173};
174#line 234 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/paravirt.h"
175struct static_key;
176#line 234
177struct static_key;
178#line 153 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/processor.h"
179struct seq_operations;
180#line 23 "include/asm-generic/atomic-long.h"
181typedef atomic64_t atomic_long_t;
182#line 14 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
183typedef u16 __ticket_t;
184#line 15 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
185typedef u32 __ticketpair_t;
186#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
187struct __raw_tickets {
188 __ticket_t head ;
189 __ticket_t tail ;
190};
191#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
192union __anonunion____missing_field_name_36 {
193 __ticketpair_t head_tail ;
194 struct __raw_tickets tickets ;
195};
196#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
197struct arch_spinlock {
198 union __anonunion____missing_field_name_36 __annonCompField17 ;
199};
200#line 20 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/spinlock_types.h"
201typedef struct arch_spinlock arch_spinlock_t;
202#line 27 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/rwlock.h"
203struct __anonstruct____missing_field_name_38 {
204 u32 read ;
205 s32 write ;
206};
207#line 27 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/rwlock.h"
208union __anonunion_arch_rwlock_t_37 {
209 s64 lock ;
210 struct __anonstruct____missing_field_name_38 __annonCompField18 ;
211};
212#line 27 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/rwlock.h"
213typedef union __anonunion_arch_rwlock_t_37 arch_rwlock_t;
214#line 12 "include/linux/lockdep.h"
215struct task_struct;
216#line 391 "include/linux/lockdep.h"
217struct lock_class_key {
218
219};
220#line 20 "include/linux/spinlock_types.h"
221struct raw_spinlock {
222 arch_spinlock_t raw_lock ;
223 unsigned int magic ;
224 unsigned int owner_cpu ;
225 void *owner ;
226};
227#line 20 "include/linux/spinlock_types.h"
228typedef struct raw_spinlock raw_spinlock_t;
229#line 64 "include/linux/spinlock_types.h"
230union __anonunion____missing_field_name_39 {
231 struct raw_spinlock rlock ;
232};
233#line 64 "include/linux/spinlock_types.h"
234struct spinlock {
235 union __anonunion____missing_field_name_39 __annonCompField19 ;
236};
237#line 64 "include/linux/spinlock_types.h"
238typedef struct spinlock spinlock_t;
239#line 11 "include/linux/rwlock_types.h"
240struct __anonstruct_rwlock_t_40 {
241 arch_rwlock_t raw_lock ;
242 unsigned int magic ;
243 unsigned int owner_cpu ;
244 void *owner ;
245};
246#line 11 "include/linux/rwlock_types.h"
247typedef struct __anonstruct_rwlock_t_40 rwlock_t;
248#line 49 "include/linux/wait.h"
249struct __wait_queue_head {
250 spinlock_t lock ;
251 struct list_head task_list ;
252};
253#line 53 "include/linux/wait.h"
254typedef struct __wait_queue_head wait_queue_head_t;
255#line 55
256struct task_struct;
257#line 119 "include/linux/seqlock.h"
258struct seqcount {
259 unsigned int sequence ;
260};
261#line 119 "include/linux/seqlock.h"
262typedef struct seqcount seqcount_t;
263#line 60 "include/linux/pageblock-flags.h"
264struct page;
265#line 48 "include/linux/mutex.h"
266struct mutex {
267 atomic_t count ;
268 spinlock_t wait_lock ;
269 struct list_head wait_list ;
270 struct task_struct *owner ;
271 char const *name ;
272 void *magic ;
273};
274#line 19 "include/linux/rwsem.h"
275struct rw_semaphore;
276#line 19
277struct rw_semaphore;
278#line 25 "include/linux/rwsem.h"
279struct rw_semaphore {
280 long count ;
281 raw_spinlock_t wait_lock ;
282 struct list_head wait_list ;
283};
284#line 25 "include/linux/completion.h"
285struct completion {
286 unsigned int done ;
287 wait_queue_head_t wait ;
288};
289#line 9 "include/linux/memory_hotplug.h"
290struct page;
291#line 18 "include/linux/ioport.h"
292struct resource {
293 resource_size_t start ;
294 resource_size_t end ;
295 char const *name ;
296 unsigned long flags ;
297 struct resource *parent ;
298 struct resource *sibling ;
299 struct resource *child ;
300};
301#line 202
302struct device;
303#line 103 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/mpspec.h"
304struct device;
305#line 14 "include/linux/time.h"
306struct timespec {
307 __kernel_time_t tv_sec ;
308 long tv_nsec ;
309};
310#line 46 "include/linux/ktime.h"
311union ktime {
312 s64 tv64 ;
313};
314#line 59 "include/linux/ktime.h"
315typedef union ktime ktime_t;
316#line 10 "include/linux/timer.h"
317struct tvec_base;
318#line 10
319struct tvec_base;
320#line 12 "include/linux/timer.h"
321struct timer_list {
322 struct list_head entry ;
323 unsigned long expires ;
324 struct tvec_base *base ;
325 void (*function)(unsigned long ) ;
326 unsigned long data ;
327 int slack ;
328 int start_pid ;
329 void *start_site ;
330 char start_comm[16] ;
331};
332#line 289
333struct hrtimer;
334#line 289
335struct hrtimer;
336#line 290
337enum hrtimer_restart;
338#line 17 "include/linux/workqueue.h"
339struct work_struct;
340#line 17
341struct work_struct;
342#line 79 "include/linux/workqueue.h"
343struct work_struct {
344 atomic_long_t data ;
345 struct list_head entry ;
346 void (*func)(struct work_struct *work ) ;
347};
348#line 42 "include/linux/pm.h"
349struct device;
350#line 50 "include/linux/pm.h"
351struct pm_message {
352 int event ;
353};
354#line 50 "include/linux/pm.h"
355typedef struct pm_message pm_message_t;
356#line 264 "include/linux/pm.h"
357struct dev_pm_ops {
358 int (*prepare)(struct device *dev ) ;
359 void (*complete)(struct device *dev ) ;
360 int (*suspend)(struct device *dev ) ;
361 int (*resume)(struct device *dev ) ;
362 int (*freeze)(struct device *dev ) ;
363 int (*thaw)(struct device *dev ) ;
364 int (*poweroff)(struct device *dev ) ;
365 int (*restore)(struct device *dev ) ;
366 int (*suspend_late)(struct device *dev ) ;
367 int (*resume_early)(struct device *dev ) ;
368 int (*freeze_late)(struct device *dev ) ;
369 int (*thaw_early)(struct device *dev ) ;
370 int (*poweroff_late)(struct device *dev ) ;
371 int (*restore_early)(struct device *dev ) ;
372 int (*suspend_noirq)(struct device *dev ) ;
373 int (*resume_noirq)(struct device *dev ) ;
374 int (*freeze_noirq)(struct device *dev ) ;
375 int (*thaw_noirq)(struct device *dev ) ;
376 int (*poweroff_noirq)(struct device *dev ) ;
377 int (*restore_noirq)(struct device *dev ) ;
378 int (*runtime_suspend)(struct device *dev ) ;
379 int (*runtime_resume)(struct device *dev ) ;
380 int (*runtime_idle)(struct device *dev ) ;
381};
382#line 458
383enum rpm_status {
384 RPM_ACTIVE = 0,
385 RPM_RESUMING = 1,
386 RPM_SUSPENDED = 2,
387 RPM_SUSPENDING = 3
388} ;
389#line 480
390enum rpm_request {
391 RPM_REQ_NONE = 0,
392 RPM_REQ_IDLE = 1,
393 RPM_REQ_SUSPEND = 2,
394 RPM_REQ_AUTOSUSPEND = 3,
395 RPM_REQ_RESUME = 4
396} ;
397#line 488
398struct wakeup_source;
399#line 488
400struct wakeup_source;
401#line 495 "include/linux/pm.h"
402struct pm_subsys_data {
403 spinlock_t lock ;
404 unsigned int refcount ;
405};
406#line 506
407struct dev_pm_qos_request;
408#line 506
409struct pm_qos_constraints;
410#line 506 "include/linux/pm.h"
411struct dev_pm_info {
412 pm_message_t power_state ;
413 unsigned int can_wakeup : 1 ;
414 unsigned int async_suspend : 1 ;
415 bool is_prepared : 1 ;
416 bool is_suspended : 1 ;
417 bool ignore_children : 1 ;
418 spinlock_t lock ;
419 struct list_head entry ;
420 struct completion completion ;
421 struct wakeup_source *wakeup ;
422 bool wakeup_path : 1 ;
423 struct timer_list suspend_timer ;
424 unsigned long timer_expires ;
425 struct work_struct work ;
426 wait_queue_head_t wait_queue ;
427 atomic_t usage_count ;
428 atomic_t child_count ;
429 unsigned int disable_depth : 3 ;
430 unsigned int idle_notification : 1 ;
431 unsigned int request_pending : 1 ;
432 unsigned int deferred_resume : 1 ;
433 unsigned int run_wake : 1 ;
434 unsigned int runtime_auto : 1 ;
435 unsigned int no_callbacks : 1 ;
436 unsigned int irq_safe : 1 ;
437 unsigned int use_autosuspend : 1 ;
438 unsigned int timer_autosuspends : 1 ;
439 enum rpm_request request ;
440 enum rpm_status runtime_status ;
441 int runtime_error ;
442 int autosuspend_delay ;
443 unsigned long last_busy ;
444 unsigned long active_jiffies ;
445 unsigned long suspended_jiffies ;
446 unsigned long accounting_timestamp ;
447 ktime_t suspend_time ;
448 s64 max_time_suspended_ns ;
449 struct dev_pm_qos_request *pq_req ;
450 struct pm_subsys_data *subsys_data ;
451 struct pm_qos_constraints *constraints ;
452};
453#line 564 "include/linux/pm.h"
454struct dev_pm_domain {
455 struct dev_pm_ops ops ;
456};
457#line 8 "include/linux/vmalloc.h"
458struct vm_area_struct;
459#line 8
460struct vm_area_struct;
461#line 994 "include/linux/mmzone.h"
462struct page;
463#line 10 "include/linux/gfp.h"
464struct vm_area_struct;
465#line 10 "include/linux/irqreturn.h"
466enum irqreturn {
467 IRQ_NONE = 0,
468 IRQ_HANDLED = 1,
469 IRQ_WAKE_THREAD = 2
470} ;
471#line 16 "include/linux/irqreturn.h"
472typedef enum irqreturn irqreturn_t;
473#line 31 "include/linux/irq.h"
474struct seq_file;
475#line 32
476struct module;
477#line 14 "include/linux/irqdesc.h"
478struct module;
479#line 65 "include/linux/profile.h"
480struct task_struct;
481#line 94 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/uaccess.h"
482struct exception_table_entry {
483 unsigned long insn ;
484 unsigned long fixup ;
485};
486#line 132 "include/linux/hardirq.h"
487struct task_struct;
488#line 100 "include/linux/rbtree.h"
489struct rb_node {
490 unsigned long rb_parent_color ;
491 struct rb_node *rb_right ;
492 struct rb_node *rb_left ;
493} __attribute__((__aligned__(sizeof(long )))) ;
494#line 110 "include/linux/rbtree.h"
495struct rb_root {
496 struct rb_node *rb_node ;
497};
498#line 8 "include/linux/timerqueue.h"
499struct timerqueue_node {
500 struct rb_node node ;
501 ktime_t expires ;
502};
503#line 13 "include/linux/timerqueue.h"
504struct timerqueue_head {
505 struct rb_root head ;
506 struct timerqueue_node *next ;
507};
508#line 27 "include/linux/hrtimer.h"
509struct hrtimer_clock_base;
510#line 27
511struct hrtimer_clock_base;
512#line 28
513struct hrtimer_cpu_base;
514#line 28
515struct hrtimer_cpu_base;
516#line 44
517enum hrtimer_restart {
518 HRTIMER_NORESTART = 0,
519 HRTIMER_RESTART = 1
520} ;
521#line 108 "include/linux/hrtimer.h"
522struct hrtimer {
523 struct timerqueue_node node ;
524 ktime_t _softexpires ;
525 enum hrtimer_restart (*function)(struct hrtimer * ) ;
526 struct hrtimer_clock_base *base ;
527 unsigned long state ;
528 int start_pid ;
529 void *start_site ;
530 char start_comm[16] ;
531};
532#line 145 "include/linux/hrtimer.h"
533struct hrtimer_clock_base {
534 struct hrtimer_cpu_base *cpu_base ;
535 int index ;
536 clockid_t clockid ;
537 struct timerqueue_head active ;
538 ktime_t resolution ;
539 ktime_t (*get_time)(void) ;
540 ktime_t softirq_time ;
541 ktime_t offset ;
542};
543#line 178 "include/linux/hrtimer.h"
544struct hrtimer_cpu_base {
545 raw_spinlock_t lock ;
546 unsigned long active_bases ;
547 ktime_t expires_next ;
548 int hres_active ;
549 int hang_detected ;
550 unsigned long nr_events ;
551 unsigned long nr_retries ;
552 unsigned long nr_hangs ;
553 ktime_t max_hang_time ;
554 struct hrtimer_clock_base clock_base[3] ;
555};
556#line 22 "include/linux/kref.h"
557struct kref {
558 atomic_t refcount ;
559};
560#line 187 "include/linux/interrupt.h"
561struct device;
562#line 695
563struct seq_file;
564#line 20 "include/linux/rtc.h"
565struct rtc_time {
566 int tm_sec ;
567 int tm_min ;
568 int tm_hour ;
569 int tm_mday ;
570 int tm_mon ;
571 int tm_year ;
572 int tm_wday ;
573 int tm_yday ;
574 int tm_isdst ;
575};
576#line 36 "include/linux/rtc.h"
577struct rtc_wkalrm {
578 unsigned char enabled ;
579 unsigned char pending ;
580 struct rtc_time time ;
581};
582#line 20 "include/linux/kobject_ns.h"
583struct sock;
584#line 20
585struct sock;
586#line 21
587struct kobject;
588#line 21
589struct kobject;
590#line 27
591enum kobj_ns_type {
592 KOBJ_NS_TYPE_NONE = 0,
593 KOBJ_NS_TYPE_NET = 1,
594 KOBJ_NS_TYPES = 2
595} ;
596#line 40 "include/linux/kobject_ns.h"
597struct kobj_ns_type_operations {
598 enum kobj_ns_type type ;
599 void *(*grab_current_ns)(void) ;
600 void const *(*netlink_ns)(struct sock *sk ) ;
601 void const *(*initial_ns)(void) ;
602 void (*drop_ns)(void * ) ;
603};
604#line 22 "include/linux/sysfs.h"
605struct kobject;
606#line 23
607struct module;
608#line 24
609enum kobj_ns_type;
610#line 26 "include/linux/sysfs.h"
611struct attribute {
612 char const *name ;
613 umode_t mode ;
614};
615#line 56 "include/linux/sysfs.h"
616struct attribute_group {
617 char const *name ;
618 umode_t (*is_visible)(struct kobject * , struct attribute * , int ) ;
619 struct attribute **attrs ;
620};
621#line 85
622struct file;
623#line 86
624struct vm_area_struct;
625#line 88 "include/linux/sysfs.h"
626struct bin_attribute {
627 struct attribute attr ;
628 size_t size ;
629 void *private ;
630 ssize_t (*read)(struct file * , struct kobject * , struct bin_attribute * , char * ,
631 loff_t , size_t ) ;
632 ssize_t (*write)(struct file * , struct kobject * , struct bin_attribute * , char * ,
633 loff_t , size_t ) ;
634 int (*mmap)(struct file * , struct kobject * , struct bin_attribute *attr , struct vm_area_struct *vma ) ;
635};
636#line 112 "include/linux/sysfs.h"
637struct sysfs_ops {
638 ssize_t (*show)(struct kobject * , struct attribute * , char * ) ;
639 ssize_t (*store)(struct kobject * , struct attribute * , char const * , size_t ) ;
640 void const *(*namespace)(struct kobject * , struct attribute const * ) ;
641};
642#line 118
643struct sysfs_dirent;
644#line 118
645struct sysfs_dirent;
646#line 60 "include/linux/kobject.h"
647struct kset;
648#line 60
649struct kobj_type;
650#line 60 "include/linux/kobject.h"
651struct kobject {
652 char const *name ;
653 struct list_head entry ;
654 struct kobject *parent ;
655 struct kset *kset ;
656 struct kobj_type *ktype ;
657 struct sysfs_dirent *sd ;
658 struct kref kref ;
659 unsigned int state_initialized : 1 ;
660 unsigned int state_in_sysfs : 1 ;
661 unsigned int state_add_uevent_sent : 1 ;
662 unsigned int state_remove_uevent_sent : 1 ;
663 unsigned int uevent_suppress : 1 ;
664};
665#line 108 "include/linux/kobject.h"
666struct kobj_type {
667 void (*release)(struct kobject *kobj ) ;
668 struct sysfs_ops const *sysfs_ops ;
669 struct attribute **default_attrs ;
670 struct kobj_ns_type_operations const *(*child_ns_type)(struct kobject *kobj ) ;
671 void const *(*namespace)(struct kobject *kobj ) ;
672};
673#line 116 "include/linux/kobject.h"
674struct kobj_uevent_env {
675 char *envp[32] ;
676 int envp_idx ;
677 char buf[2048] ;
678 int buflen ;
679};
680#line 123 "include/linux/kobject.h"
681struct kset_uevent_ops {
682 int (* const filter)(struct kset *kset , struct kobject *kobj ) ;
683 char const *(* const name)(struct kset *kset , struct kobject *kobj ) ;
684 int (* const uevent)(struct kset *kset , struct kobject *kobj , struct kobj_uevent_env *env ) ;
685};
686#line 140
687struct sock;
688#line 159 "include/linux/kobject.h"
689struct kset {
690 struct list_head list ;
691 spinlock_t list_lock ;
692 struct kobject kobj ;
693 struct kset_uevent_ops const *uevent_ops ;
694};
695#line 19 "include/linux/klist.h"
696struct klist_node;
697#line 19
698struct klist_node;
699#line 39 "include/linux/klist.h"
700struct klist_node {
701 void *n_klist ;
702 struct list_head n_node ;
703 struct kref n_ref ;
704};
705#line 4 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/device.h"
706struct dma_map_ops;
707#line 4 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/device.h"
708struct dev_archdata {
709 void *acpi_handle ;
710 struct dma_map_ops *dma_ops ;
711 void *iommu ;
712};
713#line 16 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/device.h"
714struct pdev_archdata {
715
716};
717#line 28 "include/linux/device.h"
718struct device;
719#line 29
720struct device_private;
721#line 29
722struct device_private;
723#line 30
724struct device_driver;
725#line 30
726struct device_driver;
727#line 31
728struct driver_private;
729#line 31
730struct driver_private;
731#line 32
732struct module;
733#line 33
734struct class;
735#line 33
736struct class;
737#line 34
738struct subsys_private;
739#line 34
740struct subsys_private;
741#line 35
742struct bus_type;
743#line 35
744struct bus_type;
745#line 36
746struct device_node;
747#line 36
748struct device_node;
749#line 37
750struct iommu_ops;
751#line 37
752struct iommu_ops;
753#line 39 "include/linux/device.h"
754struct bus_attribute {
755 struct attribute attr ;
756 ssize_t (*show)(struct bus_type *bus , char *buf ) ;
757 ssize_t (*store)(struct bus_type *bus , char const *buf , size_t count ) ;
758};
759#line 89
760struct device_attribute;
761#line 89
762struct driver_attribute;
763#line 89 "include/linux/device.h"
764struct bus_type {
765 char const *name ;
766 char const *dev_name ;
767 struct device *dev_root ;
768 struct bus_attribute *bus_attrs ;
769 struct device_attribute *dev_attrs ;
770 struct driver_attribute *drv_attrs ;
771 int (*match)(struct device *dev , struct device_driver *drv ) ;
772 int (*uevent)(struct device *dev , struct kobj_uevent_env *env ) ;
773 int (*probe)(struct device *dev ) ;
774 int (*remove)(struct device *dev ) ;
775 void (*shutdown)(struct device *dev ) ;
776 int (*suspend)(struct device *dev , pm_message_t state ) ;
777 int (*resume)(struct device *dev ) ;
778 struct dev_pm_ops const *pm ;
779 struct iommu_ops *iommu_ops ;
780 struct subsys_private *p ;
781};
782#line 127
783struct device_type;
784#line 214
785struct of_device_id;
786#line 214 "include/linux/device.h"
787struct device_driver {
788 char const *name ;
789 struct bus_type *bus ;
790 struct module *owner ;
791 char const *mod_name ;
792 bool suppress_bind_attrs ;
793 struct of_device_id const *of_match_table ;
794 int (*probe)(struct device *dev ) ;
795 int (*remove)(struct device *dev ) ;
796 void (*shutdown)(struct device *dev ) ;
797 int (*suspend)(struct device *dev , pm_message_t state ) ;
798 int (*resume)(struct device *dev ) ;
799 struct attribute_group const **groups ;
800 struct dev_pm_ops const *pm ;
801 struct driver_private *p ;
802};
803#line 249 "include/linux/device.h"
804struct driver_attribute {
805 struct attribute attr ;
806 ssize_t (*show)(struct device_driver *driver , char *buf ) ;
807 ssize_t (*store)(struct device_driver *driver , char const *buf , size_t count ) ;
808};
809#line 330
810struct class_attribute;
811#line 330 "include/linux/device.h"
812struct class {
813 char const *name ;
814 struct module *owner ;
815 struct class_attribute *class_attrs ;
816 struct device_attribute *dev_attrs ;
817 struct bin_attribute *dev_bin_attrs ;
818 struct kobject *dev_kobj ;
819 int (*dev_uevent)(struct device *dev , struct kobj_uevent_env *env ) ;
820 char *(*devnode)(struct device *dev , umode_t *mode ) ;
821 void (*class_release)(struct class *class ) ;
822 void (*dev_release)(struct device *dev ) ;
823 int (*suspend)(struct device *dev , pm_message_t state ) ;
824 int (*resume)(struct device *dev ) ;
825 struct kobj_ns_type_operations const *ns_type ;
826 void const *(*namespace)(struct device *dev ) ;
827 struct dev_pm_ops const *pm ;
828 struct subsys_private *p ;
829};
830#line 397 "include/linux/device.h"
831struct class_attribute {
832 struct attribute attr ;
833 ssize_t (*show)(struct class *class , struct class_attribute *attr , char *buf ) ;
834 ssize_t (*store)(struct class *class , struct class_attribute *attr , char const *buf ,
835 size_t count ) ;
836 void const *(*namespace)(struct class *class , struct class_attribute const *attr ) ;
837};
838#line 465 "include/linux/device.h"
839struct device_type {
840 char const *name ;
841 struct attribute_group const **groups ;
842 int (*uevent)(struct device *dev , struct kobj_uevent_env *env ) ;
843 char *(*devnode)(struct device *dev , umode_t *mode ) ;
844 void (*release)(struct device *dev ) ;
845 struct dev_pm_ops const *pm ;
846};
847#line 476 "include/linux/device.h"
848struct device_attribute {
849 struct attribute attr ;
850 ssize_t (*show)(struct device *dev , struct device_attribute *attr , char *buf ) ;
851 ssize_t (*store)(struct device *dev , struct device_attribute *attr , char const *buf ,
852 size_t count ) ;
853};
854#line 559 "include/linux/device.h"
855struct device_dma_parameters {
856 unsigned int max_segment_size ;
857 unsigned long segment_boundary_mask ;
858};
859#line 627
860struct dma_coherent_mem;
861#line 627 "include/linux/device.h"
862struct device {
863 struct device *parent ;
864 struct device_private *p ;
865 struct kobject kobj ;
866 char const *init_name ;
867 struct device_type const *type ;
868 struct mutex mutex ;
869 struct bus_type *bus ;
870 struct device_driver *driver ;
871 void *platform_data ;
872 struct dev_pm_info power ;
873 struct dev_pm_domain *pm_domain ;
874 int numa_node ;
875 u64 *dma_mask ;
876 u64 coherent_dma_mask ;
877 struct device_dma_parameters *dma_parms ;
878 struct list_head dma_pools ;
879 struct dma_coherent_mem *dma_mem ;
880 struct dev_archdata archdata ;
881 struct device_node *of_node ;
882 dev_t devt ;
883 u32 id ;
884 spinlock_t devres_lock ;
885 struct list_head devres_head ;
886 struct klist_node knode_class ;
887 struct class *class ;
888 struct attribute_group const **groups ;
889 void (*release)(struct device *dev ) ;
890};
891#line 43 "include/linux/pm_wakeup.h"
892struct wakeup_source {
893 char const *name ;
894 struct list_head entry ;
895 spinlock_t lock ;
896 struct timer_list timer ;
897 unsigned long timer_expires ;
898 ktime_t total_time ;
899 ktime_t max_time ;
900 ktime_t last_time ;
901 unsigned long event_count ;
902 unsigned long active_count ;
903 unsigned long relax_count ;
904 unsigned long hit_count ;
905 unsigned int active : 1 ;
906};
907#line 11 "include/linux/seq_file.h"
908struct seq_operations;
909#line 12
910struct file;
911#line 13
912struct path;
913#line 13
914struct path;
915#line 14
916struct inode;
917#line 14
918struct inode;
919#line 15
920struct dentry;
921#line 15
922struct dentry;
923#line 17 "include/linux/seq_file.h"
924struct seq_file {
925 char *buf ;
926 size_t size ;
927 size_t from ;
928 size_t count ;
929 loff_t index ;
930 loff_t read_pos ;
931 u64 version ;
932 struct mutex lock ;
933 struct seq_operations const *op ;
934 int poll_event ;
935 void *private ;
936};
937#line 31 "include/linux/seq_file.h"
938struct seq_operations {
939 void *(*start)(struct seq_file *m , loff_t *pos ) ;
940 void (*stop)(struct seq_file *m , void *v ) ;
941 void *(*next)(struct seq_file *m , void *v , loff_t *pos ) ;
942 int (*show)(struct seq_file *m , void *v ) ;
943};
944#line 8 "include/linux/cdev.h"
945struct file_operations;
946#line 8
947struct file_operations;
948#line 9
949struct inode;
950#line 10
951struct module;
952#line 12 "include/linux/cdev.h"
953struct cdev {
954 struct kobject kobj ;
955 struct module *owner ;
956 struct file_operations const *ops ;
957 struct list_head list ;
958 dev_t dev ;
959 unsigned int count ;
960};
961#line 33
962struct backing_dev_info;
963#line 15 "include/linux/blk_types.h"
964struct page;
965#line 16
966struct block_device;
967#line 16
968struct block_device;
969#line 33 "include/linux/list_bl.h"
970struct hlist_bl_node;
971#line 33 "include/linux/list_bl.h"
972struct hlist_bl_head {
973 struct hlist_bl_node *first ;
974};
975#line 37 "include/linux/list_bl.h"
976struct hlist_bl_node {
977 struct hlist_bl_node *next ;
978 struct hlist_bl_node **pprev ;
979};
980#line 13 "include/linux/dcache.h"
981struct nameidata;
982#line 13
983struct nameidata;
984#line 14
985struct path;
986#line 15
987struct vfsmount;
988#line 15
989struct vfsmount;
990#line 35 "include/linux/dcache.h"
991struct qstr {
992 unsigned int hash ;
993 unsigned int len ;
994 unsigned char const *name ;
995};
996#line 88
997struct dentry_operations;
998#line 88
999struct super_block;
1000#line 88 "include/linux/dcache.h"
1001union __anonunion_d_u_147 {
1002 struct list_head d_child ;
1003 struct rcu_head d_rcu ;
1004};
1005#line 88 "include/linux/dcache.h"
1006struct dentry {
1007 unsigned int d_flags ;
1008 seqcount_t d_seq ;
1009 struct hlist_bl_node d_hash ;
1010 struct dentry *d_parent ;
1011 struct qstr d_name ;
1012 struct inode *d_inode ;
1013 unsigned char d_iname[32] ;
1014 unsigned int d_count ;
1015 spinlock_t d_lock ;
1016 struct dentry_operations const *d_op ;
1017 struct super_block *d_sb ;
1018 unsigned long d_time ;
1019 void *d_fsdata ;
1020 struct list_head d_lru ;
1021 union __anonunion_d_u_147 d_u ;
1022 struct list_head d_subdirs ;
1023 struct list_head d_alias ;
1024};
1025#line 131 "include/linux/dcache.h"
1026struct dentry_operations {
1027 int (*d_revalidate)(struct dentry * , struct nameidata * ) ;
1028 int (*d_hash)(struct dentry const * , struct inode const * , struct qstr * ) ;
1029 int (*d_compare)(struct dentry const * , struct inode const * , struct dentry const * ,
1030 struct inode const * , unsigned int , char const * , struct qstr const * ) ;
1031 int (*d_delete)(struct dentry const * ) ;
1032 void (*d_release)(struct dentry * ) ;
1033 void (*d_prune)(struct dentry * ) ;
1034 void (*d_iput)(struct dentry * , struct inode * ) ;
1035 char *(*d_dname)(struct dentry * , char * , int ) ;
1036 struct vfsmount *(*d_automount)(struct path * ) ;
1037 int (*d_manage)(struct dentry * , bool ) ;
1038} __attribute__((__aligned__((1) << (6) ))) ;
1039#line 4 "include/linux/path.h"
1040struct dentry;
1041#line 5
1042struct vfsmount;
1043#line 7 "include/linux/path.h"
1044struct path {
1045 struct vfsmount *mnt ;
1046 struct dentry *dentry ;
1047};
1048#line 62 "include/linux/stat.h"
1049struct kstat {
1050 u64 ino ;
1051 dev_t dev ;
1052 umode_t mode ;
1053 unsigned int nlink ;
1054 uid_t uid ;
1055 gid_t gid ;
1056 dev_t rdev ;
1057 loff_t size ;
1058 struct timespec atime ;
1059 struct timespec mtime ;
1060 struct timespec ctime ;
1061 unsigned long blksize ;
1062 unsigned long long blocks ;
1063};
1064#line 64 "include/linux/radix-tree.h"
1065struct radix_tree_node;
1066#line 64 "include/linux/radix-tree.h"
1067struct radix_tree_root {
1068 unsigned int height ;
1069 gfp_t gfp_mask ;
1070 struct radix_tree_node *rnode ;
1071};
1072#line 14 "include/linux/prio_tree.h"
1073struct prio_tree_node;
1074#line 20 "include/linux/prio_tree.h"
1075struct prio_tree_node {
1076 struct prio_tree_node *left ;
1077 struct prio_tree_node *right ;
1078 struct prio_tree_node *parent ;
1079 unsigned long start ;
1080 unsigned long last ;
1081};
1082#line 28 "include/linux/prio_tree.h"
1083struct prio_tree_root {
1084 struct prio_tree_node *prio_tree_node ;
1085 unsigned short index_bits ;
1086 unsigned short raw ;
1087};
1088#line 6 "include/linux/pid.h"
1089enum pid_type {
1090 PIDTYPE_PID = 0,
1091 PIDTYPE_PGID = 1,
1092 PIDTYPE_SID = 2,
1093 PIDTYPE_MAX = 3
1094} ;
1095#line 50
1096struct pid_namespace;
1097#line 50 "include/linux/pid.h"
1098struct upid {
1099 int nr ;
1100 struct pid_namespace *ns ;
1101 struct hlist_node pid_chain ;
1102};
1103#line 57 "include/linux/pid.h"
1104struct pid {
1105 atomic_t count ;
1106 unsigned int level ;
1107 struct hlist_head tasks[3] ;
1108 struct rcu_head rcu ;
1109 struct upid numbers[1] ;
1110};
1111#line 100
1112struct pid_namespace;
1113#line 18 "include/linux/capability.h"
1114struct task_struct;
1115#line 377
1116struct dentry;
1117#line 16 "include/linux/fiemap.h"
1118struct fiemap_extent {
1119 __u64 fe_logical ;
1120 __u64 fe_physical ;
1121 __u64 fe_length ;
1122 __u64 fe_reserved64[2] ;
1123 __u32 fe_flags ;
1124 __u32 fe_reserved[3] ;
1125};
1126#line 8 "include/linux/shrinker.h"
1127struct shrink_control {
1128 gfp_t gfp_mask ;
1129 unsigned long nr_to_scan ;
1130};
1131#line 31 "include/linux/shrinker.h"
1132struct shrinker {
1133 int (*shrink)(struct shrinker * , struct shrink_control *sc ) ;
1134 int seeks ;
1135 long batch ;
1136 struct list_head list ;
1137 atomic_long_t nr_in_batch ;
1138};
1139#line 10 "include/linux/migrate_mode.h"
1140enum migrate_mode {
1141 MIGRATE_ASYNC = 0,
1142 MIGRATE_SYNC_LIGHT = 1,
1143 MIGRATE_SYNC = 2
1144} ;
1145#line 408 "include/linux/fs.h"
1146struct export_operations;
1147#line 408
1148struct export_operations;
1149#line 410
1150struct iovec;
1151#line 410
1152struct iovec;
1153#line 411
1154struct nameidata;
1155#line 412
1156struct kiocb;
1157#line 412
1158struct kiocb;
1159#line 413
1160struct kobject;
1161#line 414
1162struct pipe_inode_info;
1163#line 414
1164struct pipe_inode_info;
1165#line 415
1166struct poll_table_struct;
1167#line 415
1168struct poll_table_struct;
1169#line 416
1170struct kstatfs;
1171#line 416
1172struct kstatfs;
1173#line 417
1174struct vm_area_struct;
1175#line 418
1176struct vfsmount;
1177#line 419
1178struct cred;
1179#line 419
1180struct cred;
1181#line 469 "include/linux/fs.h"
1182struct iattr {
1183 unsigned int ia_valid ;
1184 umode_t ia_mode ;
1185 uid_t ia_uid ;
1186 gid_t ia_gid ;
1187 loff_t ia_size ;
1188 struct timespec ia_atime ;
1189 struct timespec ia_mtime ;
1190 struct timespec ia_ctime ;
1191 struct file *ia_file ;
1192};
1193#line 129 "include/linux/quota.h"
1194struct if_dqinfo {
1195 __u64 dqi_bgrace ;
1196 __u64 dqi_igrace ;
1197 __u32 dqi_flags ;
1198 __u32 dqi_valid ;
1199};
1200#line 50 "include/linux/dqblk_xfs.h"
1201struct fs_disk_quota {
1202 __s8 d_version ;
1203 __s8 d_flags ;
1204 __u16 d_fieldmask ;
1205 __u32 d_id ;
1206 __u64 d_blk_hardlimit ;
1207 __u64 d_blk_softlimit ;
1208 __u64 d_ino_hardlimit ;
1209 __u64 d_ino_softlimit ;
1210 __u64 d_bcount ;
1211 __u64 d_icount ;
1212 __s32 d_itimer ;
1213 __s32 d_btimer ;
1214 __u16 d_iwarns ;
1215 __u16 d_bwarns ;
1216 __s32 d_padding2 ;
1217 __u64 d_rtb_hardlimit ;
1218 __u64 d_rtb_softlimit ;
1219 __u64 d_rtbcount ;
1220 __s32 d_rtbtimer ;
1221 __u16 d_rtbwarns ;
1222 __s16 d_padding3 ;
1223 char d_padding4[8] ;
1224};
1225#line 146 "include/linux/dqblk_xfs.h"
1226struct fs_qfilestat {
1227 __u64 qfs_ino ;
1228 __u64 qfs_nblks ;
1229 __u32 qfs_nextents ;
1230};
1231#line 146 "include/linux/dqblk_xfs.h"
1232typedef struct fs_qfilestat fs_qfilestat_t;
1233#line 152 "include/linux/dqblk_xfs.h"
1234struct fs_quota_stat {
1235 __s8 qs_version ;
1236 __u16 qs_flags ;
1237 __s8 qs_pad ;
1238 fs_qfilestat_t qs_uquota ;
1239 fs_qfilestat_t qs_gquota ;
1240 __u32 qs_incoredqs ;
1241 __s32 qs_btimelimit ;
1242 __s32 qs_itimelimit ;
1243 __s32 qs_rtbtimelimit ;
1244 __u16 qs_bwarnlimit ;
1245 __u16 qs_iwarnlimit ;
1246};
1247#line 17 "include/linux/dqblk_qtree.h"
1248struct dquot;
1249#line 17
1250struct dquot;
1251#line 185 "include/linux/quota.h"
1252typedef __kernel_uid32_t qid_t;
1253#line 186 "include/linux/quota.h"
1254typedef long long qsize_t;
1255#line 200 "include/linux/quota.h"
1256struct mem_dqblk {
1257 qsize_t dqb_bhardlimit ;
1258 qsize_t dqb_bsoftlimit ;
1259 qsize_t dqb_curspace ;
1260 qsize_t dqb_rsvspace ;
1261 qsize_t dqb_ihardlimit ;
1262 qsize_t dqb_isoftlimit ;
1263 qsize_t dqb_curinodes ;
1264 time_t dqb_btime ;
1265 time_t dqb_itime ;
1266};
1267#line 215
1268struct quota_format_type;
1269#line 215
1270struct quota_format_type;
1271#line 217 "include/linux/quota.h"
1272struct mem_dqinfo {
1273 struct quota_format_type *dqi_format ;
1274 int dqi_fmt_id ;
1275 struct list_head dqi_dirty_list ;
1276 unsigned long dqi_flags ;
1277 unsigned int dqi_bgrace ;
1278 unsigned int dqi_igrace ;
1279 qsize_t dqi_maxblimit ;
1280 qsize_t dqi_maxilimit ;
1281 void *dqi_priv ;
1282};
1283#line 230
1284struct super_block;
1285#line 288 "include/linux/quota.h"
1286struct dquot {
1287 struct hlist_node dq_hash ;
1288 struct list_head dq_inuse ;
1289 struct list_head dq_free ;
1290 struct list_head dq_dirty ;
1291 struct mutex dq_lock ;
1292 atomic_t dq_count ;
1293 wait_queue_head_t dq_wait_unused ;
1294 struct super_block *dq_sb ;
1295 unsigned int dq_id ;
1296 loff_t dq_off ;
1297 unsigned long dq_flags ;
1298 short dq_type ;
1299 struct mem_dqblk dq_dqb ;
1300};
1301#line 305 "include/linux/quota.h"
1302struct quota_format_ops {
1303 int (*check_quota_file)(struct super_block *sb , int type ) ;
1304 int (*read_file_info)(struct super_block *sb , int type ) ;
1305 int (*write_file_info)(struct super_block *sb , int type ) ;
1306 int (*free_file_info)(struct super_block *sb , int type ) ;
1307 int (*read_dqblk)(struct dquot *dquot ) ;
1308 int (*commit_dqblk)(struct dquot *dquot ) ;
1309 int (*release_dqblk)(struct dquot *dquot ) ;
1310};
1311#line 316 "include/linux/quota.h"
1312struct dquot_operations {
1313 int (*write_dquot)(struct dquot * ) ;
1314 struct dquot *(*alloc_dquot)(struct super_block * , int ) ;
1315 void (*destroy_dquot)(struct dquot * ) ;
1316 int (*acquire_dquot)(struct dquot * ) ;
1317 int (*release_dquot)(struct dquot * ) ;
1318 int (*mark_dirty)(struct dquot * ) ;
1319 int (*write_info)(struct super_block * , int ) ;
1320 qsize_t *(*get_reserved_space)(struct inode * ) ;
1321};
1322#line 329
1323struct path;
1324#line 332 "include/linux/quota.h"
1325struct quotactl_ops {
1326 int (*quota_on)(struct super_block * , int , int , struct path * ) ;
1327 int (*quota_on_meta)(struct super_block * , int , int ) ;
1328 int (*quota_off)(struct super_block * , int ) ;
1329 int (*quota_sync)(struct super_block * , int , int ) ;
1330 int (*get_info)(struct super_block * , int , struct if_dqinfo * ) ;
1331 int (*set_info)(struct super_block * , int , struct if_dqinfo * ) ;
1332 int (*get_dqblk)(struct super_block * , int , qid_t , struct fs_disk_quota * ) ;
1333 int (*set_dqblk)(struct super_block * , int , qid_t , struct fs_disk_quota * ) ;
1334 int (*get_xstate)(struct super_block * , struct fs_quota_stat * ) ;
1335 int (*set_xstate)(struct super_block * , unsigned int , int ) ;
1336};
1337#line 345 "include/linux/quota.h"
1338struct quota_format_type {
1339 int qf_fmt_id ;
1340 struct quota_format_ops const *qf_ops ;
1341 struct module *qf_owner ;
1342 struct quota_format_type *qf_next ;
1343};
1344#line 399 "include/linux/quota.h"
1345struct quota_info {
1346 unsigned int flags ;
1347 struct mutex dqio_mutex ;
1348 struct mutex dqonoff_mutex ;
1349 struct rw_semaphore dqptr_sem ;
1350 struct inode *files[2] ;
1351 struct mem_dqinfo info[2] ;
1352 struct quota_format_ops const *ops[2] ;
1353};
1354#line 532 "include/linux/fs.h"
1355struct page;
1356#line 533
1357struct address_space;
1358#line 533
1359struct address_space;
1360#line 534
1361struct writeback_control;
1362#line 534
1363struct writeback_control;
1364#line 577 "include/linux/fs.h"
1365union __anonunion_arg_155 {
1366 char *buf ;
1367 void *data ;
1368};
1369#line 577 "include/linux/fs.h"
1370struct __anonstruct_read_descriptor_t_154 {
1371 size_t written ;
1372 size_t count ;
1373 union __anonunion_arg_155 arg ;
1374 int error ;
1375};
1376#line 577 "include/linux/fs.h"
1377typedef struct __anonstruct_read_descriptor_t_154 read_descriptor_t;
1378#line 590 "include/linux/fs.h"
1379struct address_space_operations {
1380 int (*writepage)(struct page *page , struct writeback_control *wbc ) ;
1381 int (*readpage)(struct file * , struct page * ) ;
1382 int (*writepages)(struct address_space * , struct writeback_control * ) ;
1383 int (*set_page_dirty)(struct page *page ) ;
1384 int (*readpages)(struct file *filp , struct address_space *mapping , struct list_head *pages ,
1385 unsigned int nr_pages ) ;
1386 int (*write_begin)(struct file * , struct address_space *mapping , loff_t pos ,
1387 unsigned int len , unsigned int flags , struct page **pagep ,
1388 void **fsdata ) ;
1389 int (*write_end)(struct file * , struct address_space *mapping , loff_t pos , unsigned int len ,
1390 unsigned int copied , struct page *page , void *fsdata ) ;
1391 sector_t (*bmap)(struct address_space * , sector_t ) ;
1392 void (*invalidatepage)(struct page * , unsigned long ) ;
1393 int (*releasepage)(struct page * , gfp_t ) ;
1394 void (*freepage)(struct page * ) ;
1395 ssize_t (*direct_IO)(int , struct kiocb * , struct iovec const *iov , loff_t offset ,
1396 unsigned long nr_segs ) ;
1397 int (*get_xip_mem)(struct address_space * , unsigned long , int , void ** , unsigned long * ) ;
1398 int (*migratepage)(struct address_space * , struct page * , struct page * , enum migrate_mode ) ;
1399 int (*launder_page)(struct page * ) ;
1400 int (*is_partially_uptodate)(struct page * , read_descriptor_t * , unsigned long ) ;
1401 int (*error_remove_page)(struct address_space * , struct page * ) ;
1402};
1403#line 645
1404struct backing_dev_info;
1405#line 646 "include/linux/fs.h"
1406struct address_space {
1407 struct inode *host ;
1408 struct radix_tree_root page_tree ;
1409 spinlock_t tree_lock ;
1410 unsigned int i_mmap_writable ;
1411 struct prio_tree_root i_mmap ;
1412 struct list_head i_mmap_nonlinear ;
1413 struct mutex i_mmap_mutex ;
1414 unsigned long nrpages ;
1415 unsigned long writeback_index ;
1416 struct address_space_operations const *a_ops ;
1417 unsigned long flags ;
1418 struct backing_dev_info *backing_dev_info ;
1419 spinlock_t private_lock ;
1420 struct list_head private_list ;
1421 struct address_space *assoc_mapping ;
1422} __attribute__((__aligned__(sizeof(long )))) ;
1423#line 669
1424struct request_queue;
1425#line 669
1426struct request_queue;
1427#line 671
1428struct hd_struct;
1429#line 671
1430struct gendisk;
1431#line 671 "include/linux/fs.h"
1432struct block_device {
1433 dev_t bd_dev ;
1434 int bd_openers ;
1435 struct inode *bd_inode ;
1436 struct super_block *bd_super ;
1437 struct mutex bd_mutex ;
1438 struct list_head bd_inodes ;
1439 void *bd_claiming ;
1440 void *bd_holder ;
1441 int bd_holders ;
1442 bool bd_write_holder ;
1443 struct list_head bd_holder_disks ;
1444 struct block_device *bd_contains ;
1445 unsigned int bd_block_size ;
1446 struct hd_struct *bd_part ;
1447 unsigned int bd_part_count ;
1448 int bd_invalidated ;
1449 struct gendisk *bd_disk ;
1450 struct request_queue *bd_queue ;
1451 struct list_head bd_list ;
1452 unsigned long bd_private ;
1453 int bd_fsfreeze_count ;
1454 struct mutex bd_fsfreeze_mutex ;
1455};
1456#line 749
1457struct posix_acl;
1458#line 749
1459struct posix_acl;
1460#line 761
1461struct inode_operations;
1462#line 761 "include/linux/fs.h"
1463union __anonunion____missing_field_name_156 {
1464 unsigned int const i_nlink ;
1465 unsigned int __i_nlink ;
1466};
1467#line 761 "include/linux/fs.h"
1468union __anonunion____missing_field_name_157 {
1469 struct list_head i_dentry ;
1470 struct rcu_head i_rcu ;
1471};
1472#line 761
1473struct file_lock;
1474#line 761 "include/linux/fs.h"
1475union __anonunion____missing_field_name_158 {
1476 struct pipe_inode_info *i_pipe ;
1477 struct block_device *i_bdev ;
1478 struct cdev *i_cdev ;
1479};
1480#line 761 "include/linux/fs.h"
1481struct inode {
1482 umode_t i_mode ;
1483 unsigned short i_opflags ;
1484 uid_t i_uid ;
1485 gid_t i_gid ;
1486 unsigned int i_flags ;
1487 struct posix_acl *i_acl ;
1488 struct posix_acl *i_default_acl ;
1489 struct inode_operations const *i_op ;
1490 struct super_block *i_sb ;
1491 struct address_space *i_mapping ;
1492 void *i_security ;
1493 unsigned long i_ino ;
1494 union __anonunion____missing_field_name_156 __annonCompField30 ;
1495 dev_t i_rdev ;
1496 struct timespec i_atime ;
1497 struct timespec i_mtime ;
1498 struct timespec i_ctime ;
1499 spinlock_t i_lock ;
1500 unsigned short i_bytes ;
1501 blkcnt_t i_blocks ;
1502 loff_t i_size ;
1503 unsigned long i_state ;
1504 struct mutex i_mutex ;
1505 unsigned long dirtied_when ;
1506 struct hlist_node i_hash ;
1507 struct list_head i_wb_list ;
1508 struct list_head i_lru ;
1509 struct list_head i_sb_list ;
1510 union __anonunion____missing_field_name_157 __annonCompField31 ;
1511 atomic_t i_count ;
1512 unsigned int i_blkbits ;
1513 u64 i_version ;
1514 atomic_t i_dio_count ;
1515 atomic_t i_writecount ;
1516 struct file_operations const *i_fop ;
1517 struct file_lock *i_flock ;
1518 struct address_space i_data ;
1519 struct dquot *i_dquot[2] ;
1520 struct list_head i_devices ;
1521 union __anonunion____missing_field_name_158 __annonCompField32 ;
1522 __u32 i_generation ;
1523 __u32 i_fsnotify_mask ;
1524 struct hlist_head i_fsnotify_marks ;
1525 atomic_t i_readcount ;
1526 void *i_private ;
1527};
1528#line 942 "include/linux/fs.h"
1529struct fown_struct {
1530 rwlock_t lock ;
1531 struct pid *pid ;
1532 enum pid_type pid_type ;
1533 uid_t uid ;
1534 uid_t euid ;
1535 int signum ;
1536};
1537#line 953 "include/linux/fs.h"
1538struct file_ra_state {
1539 unsigned long start ;
1540 unsigned int size ;
1541 unsigned int async_size ;
1542 unsigned int ra_pages ;
1543 unsigned int mmap_miss ;
1544 loff_t prev_pos ;
1545};
1546#line 976 "include/linux/fs.h"
1547union __anonunion_f_u_159 {
1548 struct list_head fu_list ;
1549 struct rcu_head fu_rcuhead ;
1550};
1551#line 976 "include/linux/fs.h"
1552struct file {
1553 union __anonunion_f_u_159 f_u ;
1554 struct path f_path ;
1555 struct file_operations const *f_op ;
1556 spinlock_t f_lock ;
1557 int f_sb_list_cpu ;
1558 atomic_long_t f_count ;
1559 unsigned int f_flags ;
1560 fmode_t f_mode ;
1561 loff_t f_pos ;
1562 struct fown_struct f_owner ;
1563 struct cred const *f_cred ;
1564 struct file_ra_state f_ra ;
1565 u64 f_version ;
1566 void *f_security ;
1567 void *private_data ;
1568 struct list_head f_ep_links ;
1569 struct list_head f_tfile_llink ;
1570 struct address_space *f_mapping ;
1571 unsigned long f_mnt_write_state ;
1572};
1573#line 1111
1574struct files_struct;
1575#line 1111 "include/linux/fs.h"
1576typedef struct files_struct *fl_owner_t;
1577#line 1113 "include/linux/fs.h"
1578struct file_lock_operations {
1579 void (*fl_copy_lock)(struct file_lock * , struct file_lock * ) ;
1580 void (*fl_release_private)(struct file_lock * ) ;
1581};
1582#line 1118 "include/linux/fs.h"
1583struct lock_manager_operations {
1584 int (*lm_compare_owner)(struct file_lock * , struct file_lock * ) ;
1585 void (*lm_notify)(struct file_lock * ) ;
1586 int (*lm_grant)(struct file_lock * , struct file_lock * , int ) ;
1587 void (*lm_release_private)(struct file_lock * ) ;
1588 void (*lm_break)(struct file_lock * ) ;
1589 int (*lm_change)(struct file_lock ** , int ) ;
1590};
1591#line 4 "include/linux/nfs_fs_i.h"
1592struct nlm_lockowner;
1593#line 4
1594struct nlm_lockowner;
1595#line 9 "include/linux/nfs_fs_i.h"
1596struct nfs_lock_info {
1597 u32 state ;
1598 struct nlm_lockowner *owner ;
1599 struct list_head list ;
1600};
1601#line 15
1602struct nfs4_lock_state;
1603#line 15
1604struct nfs4_lock_state;
1605#line 16 "include/linux/nfs_fs_i.h"
1606struct nfs4_lock_info {
1607 struct nfs4_lock_state *owner ;
1608};
1609#line 1138 "include/linux/fs.h"
1610struct fasync_struct;
1611#line 1138 "include/linux/fs.h"
1612struct __anonstruct_afs_161 {
1613 struct list_head link ;
1614 int state ;
1615};
1616#line 1138 "include/linux/fs.h"
1617union __anonunion_fl_u_160 {
1618 struct nfs_lock_info nfs_fl ;
1619 struct nfs4_lock_info nfs4_fl ;
1620 struct __anonstruct_afs_161 afs ;
1621};
1622#line 1138 "include/linux/fs.h"
1623struct file_lock {
1624 struct file_lock *fl_next ;
1625 struct list_head fl_link ;
1626 struct list_head fl_block ;
1627 fl_owner_t fl_owner ;
1628 unsigned int fl_flags ;
1629 unsigned char fl_type ;
1630 unsigned int fl_pid ;
1631 struct pid *fl_nspid ;
1632 wait_queue_head_t fl_wait ;
1633 struct file *fl_file ;
1634 loff_t fl_start ;
1635 loff_t fl_end ;
1636 struct fasync_struct *fl_fasync ;
1637 unsigned long fl_break_time ;
1638 unsigned long fl_downgrade_time ;
1639 struct file_lock_operations const *fl_ops ;
1640 struct lock_manager_operations const *fl_lmops ;
1641 union __anonunion_fl_u_160 fl_u ;
1642};
1643#line 1378 "include/linux/fs.h"
1644struct fasync_struct {
1645 spinlock_t fa_lock ;
1646 int magic ;
1647 int fa_fd ;
1648 struct fasync_struct *fa_next ;
1649 struct file *fa_file ;
1650 struct rcu_head fa_rcu ;
1651};
1652#line 1418
1653struct file_system_type;
1654#line 1418
1655struct super_operations;
1656#line 1418
1657struct xattr_handler;
1658#line 1418
1659struct mtd_info;
1660#line 1418 "include/linux/fs.h"
1661struct super_block {
1662 struct list_head s_list ;
1663 dev_t s_dev ;
1664 unsigned char s_dirt ;
1665 unsigned char s_blocksize_bits ;
1666 unsigned long s_blocksize ;
1667 loff_t s_maxbytes ;
1668 struct file_system_type *s_type ;
1669 struct super_operations const *s_op ;
1670 struct dquot_operations const *dq_op ;
1671 struct quotactl_ops const *s_qcop ;
1672 struct export_operations const *s_export_op ;
1673 unsigned long s_flags ;
1674 unsigned long s_magic ;
1675 struct dentry *s_root ;
1676 struct rw_semaphore s_umount ;
1677 struct mutex s_lock ;
1678 int s_count ;
1679 atomic_t s_active ;
1680 void *s_security ;
1681 struct xattr_handler const **s_xattr ;
1682 struct list_head s_inodes ;
1683 struct hlist_bl_head s_anon ;
1684 struct list_head *s_files ;
1685 struct list_head s_mounts ;
1686 struct list_head s_dentry_lru ;
1687 int s_nr_dentry_unused ;
1688 spinlock_t s_inode_lru_lock __attribute__((__aligned__((1) << (6) ))) ;
1689 struct list_head s_inode_lru ;
1690 int s_nr_inodes_unused ;
1691 struct block_device *s_bdev ;
1692 struct backing_dev_info *s_bdi ;
1693 struct mtd_info *s_mtd ;
1694 struct hlist_node s_instances ;
1695 struct quota_info s_dquot ;
1696 int s_frozen ;
1697 wait_queue_head_t s_wait_unfrozen ;
1698 char s_id[32] ;
1699 u8 s_uuid[16] ;
1700 void *s_fs_info ;
1701 unsigned int s_max_links ;
1702 fmode_t s_mode ;
1703 u32 s_time_gran ;
1704 struct mutex s_vfs_rename_mutex ;
1705 char *s_subtype ;
1706 char *s_options ;
1707 struct dentry_operations const *s_d_op ;
1708 int cleancache_poolid ;
1709 struct shrinker s_shrink ;
1710 atomic_long_t s_remove_count ;
1711 int s_readonly_remount ;
1712};
1713#line 1567 "include/linux/fs.h"
1714struct fiemap_extent_info {
1715 unsigned int fi_flags ;
1716 unsigned int fi_extents_mapped ;
1717 unsigned int fi_extents_max ;
1718 struct fiemap_extent *fi_extents_start ;
1719};
1720#line 1609 "include/linux/fs.h"
1721struct file_operations {
1722 struct module *owner ;
1723 loff_t (*llseek)(struct file * , loff_t , int ) ;
1724 ssize_t (*read)(struct file * , char * , size_t , loff_t * ) ;
1725 ssize_t (*write)(struct file * , char const * , size_t , loff_t * ) ;
1726 ssize_t (*aio_read)(struct kiocb * , struct iovec const * , unsigned long ,
1727 loff_t ) ;
1728 ssize_t (*aio_write)(struct kiocb * , struct iovec const * , unsigned long ,
1729 loff_t ) ;
1730 int (*readdir)(struct file * , void * , int (*)(void * , char const * , int ,
1731 loff_t , u64 , unsigned int ) ) ;
1732 unsigned int (*poll)(struct file * , struct poll_table_struct * ) ;
1733 long (*unlocked_ioctl)(struct file * , unsigned int , unsigned long ) ;
1734 long (*compat_ioctl)(struct file * , unsigned int , unsigned long ) ;
1735 int (*mmap)(struct file * , struct vm_area_struct * ) ;
1736 int (*open)(struct inode * , struct file * ) ;
1737 int (*flush)(struct file * , fl_owner_t id ) ;
1738 int (*release)(struct inode * , struct file * ) ;
1739 int (*fsync)(struct file * , loff_t , loff_t , int datasync ) ;
1740 int (*aio_fsync)(struct kiocb * , int datasync ) ;
1741 int (*fasync)(int , struct file * , int ) ;
1742 int (*lock)(struct file * , int , struct file_lock * ) ;
1743 ssize_t (*sendpage)(struct file * , struct page * , int , size_t , loff_t * ,
1744 int ) ;
1745 unsigned long (*get_unmapped_area)(struct file * , unsigned long , unsigned long ,
1746 unsigned long , unsigned long ) ;
1747 int (*check_flags)(int ) ;
1748 int (*flock)(struct file * , int , struct file_lock * ) ;
1749 ssize_t (*splice_write)(struct pipe_inode_info * , struct file * , loff_t * , size_t ,
1750 unsigned int ) ;
1751 ssize_t (*splice_read)(struct file * , loff_t * , struct pipe_inode_info * , size_t ,
1752 unsigned int ) ;
1753 int (*setlease)(struct file * , long , struct file_lock ** ) ;
1754 long (*fallocate)(struct file *file , int mode , loff_t offset , loff_t len ) ;
1755};
1756#line 1639 "include/linux/fs.h"
1757struct inode_operations {
1758 struct dentry *(*lookup)(struct inode * , struct dentry * , struct nameidata * ) ;
1759 void *(*follow_link)(struct dentry * , struct nameidata * ) ;
1760 int (*permission)(struct inode * , int ) ;
1761 struct posix_acl *(*get_acl)(struct inode * , int ) ;
1762 int (*readlink)(struct dentry * , char * , int ) ;
1763 void (*put_link)(struct dentry * , struct nameidata * , void * ) ;
1764 int (*create)(struct inode * , struct dentry * , umode_t , struct nameidata * ) ;
1765 int (*link)(struct dentry * , struct inode * , struct dentry * ) ;
1766 int (*unlink)(struct inode * , struct dentry * ) ;
1767 int (*symlink)(struct inode * , struct dentry * , char const * ) ;
1768 int (*mkdir)(struct inode * , struct dentry * , umode_t ) ;
1769 int (*rmdir)(struct inode * , struct dentry * ) ;
1770 int (*mknod)(struct inode * , struct dentry * , umode_t , dev_t ) ;
1771 int (*rename)(struct inode * , struct dentry * , struct inode * , struct dentry * ) ;
1772 void (*truncate)(struct inode * ) ;
1773 int (*setattr)(struct dentry * , struct iattr * ) ;
1774 int (*getattr)(struct vfsmount *mnt , struct dentry * , struct kstat * ) ;
1775 int (*setxattr)(struct dentry * , char const * , void const * , size_t , int ) ;
1776 ssize_t (*getxattr)(struct dentry * , char const * , void * , size_t ) ;
1777 ssize_t (*listxattr)(struct dentry * , char * , size_t ) ;
1778 int (*removexattr)(struct dentry * , char const * ) ;
1779 void (*truncate_range)(struct inode * , loff_t , loff_t ) ;
1780 int (*fiemap)(struct inode * , struct fiemap_extent_info * , u64 start , u64 len ) ;
1781} __attribute__((__aligned__((1) << (6) ))) ;
1782#line 1669
1783struct seq_file;
1784#line 1684 "include/linux/fs.h"
1785struct super_operations {
1786 struct inode *(*alloc_inode)(struct super_block *sb ) ;
1787 void (*destroy_inode)(struct inode * ) ;
1788 void (*dirty_inode)(struct inode * , int flags ) ;
1789 int (*write_inode)(struct inode * , struct writeback_control *wbc ) ;
1790 int (*drop_inode)(struct inode * ) ;
1791 void (*evict_inode)(struct inode * ) ;
1792 void (*put_super)(struct super_block * ) ;
1793 void (*write_super)(struct super_block * ) ;
1794 int (*sync_fs)(struct super_block *sb , int wait ) ;
1795 int (*freeze_fs)(struct super_block * ) ;
1796 int (*unfreeze_fs)(struct super_block * ) ;
1797 int (*statfs)(struct dentry * , struct kstatfs * ) ;
1798 int (*remount_fs)(struct super_block * , int * , char * ) ;
1799 void (*umount_begin)(struct super_block * ) ;
1800 int (*show_options)(struct seq_file * , struct dentry * ) ;
1801 int (*show_devname)(struct seq_file * , struct dentry * ) ;
1802 int (*show_path)(struct seq_file * , struct dentry * ) ;
1803 int (*show_stats)(struct seq_file * , struct dentry * ) ;
1804 ssize_t (*quota_read)(struct super_block * , int , char * , size_t , loff_t ) ;
1805 ssize_t (*quota_write)(struct super_block * , int , char const * , size_t ,
1806 loff_t ) ;
1807 int (*bdev_try_to_free_page)(struct super_block * , struct page * , gfp_t ) ;
1808 int (*nr_cached_objects)(struct super_block * ) ;
1809 void (*free_cached_objects)(struct super_block * , int ) ;
1810};
1811#line 1835 "include/linux/fs.h"
1812struct file_system_type {
1813 char const *name ;
1814 int fs_flags ;
1815 struct dentry *(*mount)(struct file_system_type * , int , char const * , void * ) ;
1816 void (*kill_sb)(struct super_block * ) ;
1817 struct module *owner ;
1818 struct file_system_type *next ;
1819 struct hlist_head fs_supers ;
1820 struct lock_class_key s_lock_key ;
1821 struct lock_class_key s_umount_key ;
1822 struct lock_class_key s_vfs_rename_key ;
1823 struct lock_class_key i_lock_key ;
1824 struct lock_class_key i_mutex_key ;
1825 struct lock_class_key i_mutex_dir_key ;
1826};
1827#line 29 "include/linux/sysctl.h"
1828struct completion;
1829#line 28 "include/linux/poll.h"
1830struct poll_table_struct;
1831#line 39 "include/linux/poll.h"
1832struct poll_table_struct {
1833 void (*_qproc)(struct file * , wait_queue_head_t * , struct poll_table_struct * ) ;
1834 unsigned long _key ;
1835};
1836#line 143 "include/linux/rtc.h"
1837struct rtc_class_ops {
1838 int (*open)(struct device * ) ;
1839 void (*release)(struct device * ) ;
1840 int (*ioctl)(struct device * , unsigned int , unsigned long ) ;
1841 int (*read_time)(struct device * , struct rtc_time * ) ;
1842 int (*set_time)(struct device * , struct rtc_time * ) ;
1843 int (*read_alarm)(struct device * , struct rtc_wkalrm * ) ;
1844 int (*set_alarm)(struct device * , struct rtc_wkalrm * ) ;
1845 int (*proc)(struct device * , struct seq_file * ) ;
1846 int (*set_mmss)(struct device * , unsigned long secs ) ;
1847 int (*read_callback)(struct device * , int data ) ;
1848 int (*alarm_irq_enable)(struct device * , unsigned int enabled ) ;
1849};
1850#line 158 "include/linux/rtc.h"
1851struct rtc_task {
1852 void (*func)(void *private_data ) ;
1853 void *private_data ;
1854};
1855#line 164 "include/linux/rtc.h"
1856struct rtc_timer {
1857 struct rtc_task task ;
1858 struct timerqueue_node node ;
1859 ktime_t period ;
1860 int enabled ;
1861};
1862#line 175 "include/linux/rtc.h"
1863struct rtc_device {
1864 struct device dev ;
1865 struct module *owner ;
1866 int id ;
1867 char name[20] ;
1868 struct rtc_class_ops const *ops ;
1869 struct mutex ops_lock ;
1870 struct cdev char_dev ;
1871 unsigned long flags ;
1872 unsigned long irq_data ;
1873 spinlock_t irq_lock ;
1874 wait_queue_head_t irq_queue ;
1875 struct fasync_struct *async_queue ;
1876 struct rtc_task *irq_task ;
1877 spinlock_t irq_task_lock ;
1878 int irq_freq ;
1879 int max_user_freq ;
1880 struct timerqueue_head timerqueue ;
1881 struct rtc_timer aie_timer ;
1882 struct rtc_timer uie_rtctimer ;
1883 struct hrtimer pie_timer ;
1884 int pie_enabled ;
1885 struct work_struct irqwork ;
1886 int uie_unsupported ;
1887 struct work_struct uie_task ;
1888 struct timer_list uie_timer ;
1889 unsigned int oldsecs ;
1890 unsigned int uie_irq_active : 1 ;
1891 unsigned int stop_uie_polling : 1 ;
1892 unsigned int uie_task_active : 1 ;
1893 unsigned int uie_timer_active : 1 ;
1894};
1895#line 12 "include/linux/mod_devicetable.h"
1896typedef unsigned long kernel_ulong_t;
1897#line 219 "include/linux/mod_devicetable.h"
1898struct of_device_id {
1899 char name[32] ;
1900 char type[32] ;
1901 char compatible[128] ;
1902 void *data ;
1903};
1904#line 506 "include/linux/mod_devicetable.h"
1905struct platform_device_id {
1906 char name[20] ;
1907 kernel_ulong_t driver_data __attribute__((__aligned__(sizeof(kernel_ulong_t )))) ;
1908};
1909#line 17 "include/linux/platform_device.h"
1910struct mfd_cell;
1911#line 17
1912struct mfd_cell;
1913#line 19 "include/linux/platform_device.h"
1914struct platform_device {
1915 char const *name ;
1916 int id ;
1917 struct device dev ;
1918 u32 num_resources ;
1919 struct resource *resource ;
1920 struct platform_device_id const *id_entry ;
1921 struct mfd_cell *mfd_cell ;
1922 struct pdev_archdata archdata ;
1923};
1924#line 164 "include/linux/platform_device.h"
1925struct platform_driver {
1926 int (*probe)(struct platform_device * ) ;
1927 int (*remove)(struct platform_device * ) ;
1928 void (*shutdown)(struct platform_device * ) ;
1929 int (*suspend)(struct platform_device * , pm_message_t state ) ;
1930 int (*resume)(struct platform_device * ) ;
1931 struct device_driver driver ;
1932 struct platform_device_id const *id_table ;
1933};
1934#line 25 "include/linux/io.h"
1935struct device;
1936#line 48 "include/linux/kmod.h"
1937struct cred;
1938#line 49
1939struct file;
1940#line 270 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/elf.h"
1941struct task_struct;
1942#line 18 "include/linux/elf.h"
1943typedef __u64 Elf64_Addr;
1944#line 19 "include/linux/elf.h"
1945typedef __u16 Elf64_Half;
1946#line 23 "include/linux/elf.h"
1947typedef __u32 Elf64_Word;
1948#line 24 "include/linux/elf.h"
1949typedef __u64 Elf64_Xword;
1950#line 194 "include/linux/elf.h"
1951struct elf64_sym {
1952 Elf64_Word st_name ;
1953 unsigned char st_info ;
1954 unsigned char st_other ;
1955 Elf64_Half st_shndx ;
1956 Elf64_Addr st_value ;
1957 Elf64_Xword st_size ;
1958};
1959#line 194 "include/linux/elf.h"
1960typedef struct elf64_sym Elf64_Sym;
1961#line 438
1962struct file;
1963#line 39 "include/linux/moduleparam.h"
1964struct kernel_param;
1965#line 39
1966struct kernel_param;
1967#line 41 "include/linux/moduleparam.h"
1968struct kernel_param_ops {
1969 int (*set)(char const *val , struct kernel_param const *kp ) ;
1970 int (*get)(char *buffer , struct kernel_param const *kp ) ;
1971 void (*free)(void *arg ) ;
1972};
1973#line 50
1974struct kparam_string;
1975#line 50
1976struct kparam_array;
1977#line 50 "include/linux/moduleparam.h"
1978union __anonunion____missing_field_name_226 {
1979 void *arg ;
1980 struct kparam_string const *str ;
1981 struct kparam_array const *arr ;
1982};
1983#line 50 "include/linux/moduleparam.h"
1984struct kernel_param {
1985 char const *name ;
1986 struct kernel_param_ops const *ops ;
1987 u16 perm ;
1988 s16 level ;
1989 union __anonunion____missing_field_name_226 __annonCompField35 ;
1990};
1991#line 63 "include/linux/moduleparam.h"
1992struct kparam_string {
1993 unsigned int maxlen ;
1994 char *string ;
1995};
1996#line 69 "include/linux/moduleparam.h"
1997struct kparam_array {
1998 unsigned int max ;
1999 unsigned int elemsize ;
2000 unsigned int *num ;
2001 struct kernel_param_ops const *ops ;
2002 void *elem ;
2003};
2004#line 445
2005struct module;
2006#line 80 "include/linux/jump_label.h"
2007struct module;
2008#line 143 "include/linux/jump_label.h"
2009struct static_key {
2010 atomic_t enabled ;
2011};
2012#line 22 "include/linux/tracepoint.h"
2013struct module;
2014#line 23
2015struct tracepoint;
2016#line 23
2017struct tracepoint;
2018#line 25 "include/linux/tracepoint.h"
2019struct tracepoint_func {
2020 void *func ;
2021 void *data ;
2022};
2023#line 30 "include/linux/tracepoint.h"
2024struct tracepoint {
2025 char const *name ;
2026 struct static_key key ;
2027 void (*regfunc)(void) ;
2028 void (*unregfunc)(void) ;
2029 struct tracepoint_func *funcs ;
2030};
2031#line 19 "include/linux/export.h"
2032struct kernel_symbol {
2033 unsigned long value ;
2034 char const *name ;
2035};
2036#line 8 "include/asm-generic/module.h"
2037struct mod_arch_specific {
2038
2039};
2040#line 35 "include/linux/module.h"
2041struct module;
2042#line 37
2043struct module_param_attrs;
2044#line 37 "include/linux/module.h"
2045struct module_kobject {
2046 struct kobject kobj ;
2047 struct module *mod ;
2048 struct kobject *drivers_dir ;
2049 struct module_param_attrs *mp ;
2050};
2051#line 44 "include/linux/module.h"
2052struct module_attribute {
2053 struct attribute attr ;
2054 ssize_t (*show)(struct module_attribute * , struct module_kobject * , char * ) ;
2055 ssize_t (*store)(struct module_attribute * , struct module_kobject * , char const * ,
2056 size_t count ) ;
2057 void (*setup)(struct module * , char const * ) ;
2058 int (*test)(struct module * ) ;
2059 void (*free)(struct module * ) ;
2060};
2061#line 71
2062struct exception_table_entry;
2063#line 199
2064enum module_state {
2065 MODULE_STATE_LIVE = 0,
2066 MODULE_STATE_COMING = 1,
2067 MODULE_STATE_GOING = 2
2068} ;
2069#line 215 "include/linux/module.h"
2070struct module_ref {
2071 unsigned long incs ;
2072 unsigned long decs ;
2073} __attribute__((__aligned__((2) * (sizeof(unsigned long )) ))) ;
2074#line 220
2075struct module_sect_attrs;
2076#line 220
2077struct module_notes_attrs;
2078#line 220
2079struct ftrace_event_call;
2080#line 220 "include/linux/module.h"
2081struct module {
2082 enum module_state state ;
2083 struct list_head list ;
2084 char name[64UL - sizeof(unsigned long )] ;
2085 struct module_kobject mkobj ;
2086 struct module_attribute *modinfo_attrs ;
2087 char const *version ;
2088 char const *srcversion ;
2089 struct kobject *holders_dir ;
2090 struct kernel_symbol const *syms ;
2091 unsigned long const *crcs ;
2092 unsigned int num_syms ;
2093 struct kernel_param *kp ;
2094 unsigned int num_kp ;
2095 unsigned int num_gpl_syms ;
2096 struct kernel_symbol const *gpl_syms ;
2097 unsigned long const *gpl_crcs ;
2098 struct kernel_symbol const *unused_syms ;
2099 unsigned long const *unused_crcs ;
2100 unsigned int num_unused_syms ;
2101 unsigned int num_unused_gpl_syms ;
2102 struct kernel_symbol const *unused_gpl_syms ;
2103 unsigned long const *unused_gpl_crcs ;
2104 struct kernel_symbol const *gpl_future_syms ;
2105 unsigned long const *gpl_future_crcs ;
2106 unsigned int num_gpl_future_syms ;
2107 unsigned int num_exentries ;
2108 struct exception_table_entry *extable ;
2109 int (*init)(void) ;
2110 void *module_init ;
2111 void *module_core ;
2112 unsigned int init_size ;
2113 unsigned int core_size ;
2114 unsigned int init_text_size ;
2115 unsigned int core_text_size ;
2116 unsigned int init_ro_size ;
2117 unsigned int core_ro_size ;
2118 struct mod_arch_specific arch ;
2119 unsigned int taints ;
2120 unsigned int num_bugs ;
2121 struct list_head bug_list ;
2122 struct bug_entry *bug_table ;
2123 Elf64_Sym *symtab ;
2124 Elf64_Sym *core_symtab ;
2125 unsigned int num_symtab ;
2126 unsigned int core_num_syms ;
2127 char *strtab ;
2128 char *core_strtab ;
2129 struct module_sect_attrs *sect_attrs ;
2130 struct module_notes_attrs *notes_attrs ;
2131 char *args ;
2132 void *percpu ;
2133 unsigned int percpu_size ;
2134 unsigned int num_tracepoints ;
2135 struct tracepoint * const *tracepoints_ptrs ;
2136 unsigned int num_trace_bprintk_fmt ;
2137 char const **trace_bprintk_fmt_start ;
2138 struct ftrace_event_call **trace_events ;
2139 unsigned int num_trace_events ;
2140 struct list_head source_list ;
2141 struct list_head target_list ;
2142 struct task_struct *waiter ;
2143 void (*exit)(void) ;
2144 struct module_ref *refptr ;
2145 ctor_fn_t *ctors ;
2146 unsigned int num_ctors ;
2147};
2148#line 65 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
2149struct rtc_plat_data {
2150 struct rtc_device *rtc ;
2151 void *ioaddr ;
2152 unsigned long last_jiffies ;
2153 int irq ;
2154 unsigned int irqen ;
2155 int alrm_sec ;
2156 int alrm_min ;
2157 int alrm_hour ;
2158 int alrm_mday ;
2159 spinlock_t lock ;
2160};
2161#line 1 "<compiler builtins>"
2162long __builtin_expect(long val , long res ) ;
2163#line 6 "include/linux/bcd.h"
2164extern unsigned int bcd2bin(unsigned char val ) __attribute__((__const__)) ;
2165#line 7
2166extern unsigned char bin2bcd(unsigned int val ) __attribute__((__const__)) ;
2167#line 27 "include/linux/err.h"
2168__inline static long __attribute__((__warn_unused_result__)) PTR_ERR(void const *ptr ) __attribute__((__no_instrument_function__)) ;
2169#line 27 "include/linux/err.h"
2170__inline static long __attribute__((__warn_unused_result__)) PTR_ERR(void const *ptr )
2171{
2172
2173 {
2174#line 29
2175 return ((long )ptr);
2176}
2177}
2178#line 32
2179__inline static long __attribute__((__warn_unused_result__)) IS_ERR(void const *ptr ) __attribute__((__no_instrument_function__)) ;
2180#line 32 "include/linux/err.h"
2181__inline static long __attribute__((__warn_unused_result__)) IS_ERR(void const *ptr )
2182{ long tmp ;
2183 unsigned long __cil_tmp3 ;
2184 int __cil_tmp4 ;
2185 int __cil_tmp5 ;
2186 int __cil_tmp6 ;
2187 long __cil_tmp7 ;
2188
2189 {
2190 {
2191#line 34
2192 __cil_tmp3 = (unsigned long )ptr;
2193#line 34
2194 __cil_tmp4 = __cil_tmp3 >= 0xfffffffffffff001UL;
2195#line 34
2196 __cil_tmp5 = ! __cil_tmp4;
2197#line 34
2198 __cil_tmp6 = ! __cil_tmp5;
2199#line 34
2200 __cil_tmp7 = (long )__cil_tmp6;
2201#line 34
2202 tmp = __builtin_expect(__cil_tmp7, 0L);
2203 }
2204#line 34
2205 return (tmp);
2206}
2207}
2208#line 93 "include/linux/spinlock.h"
2209extern void __raw_spin_lock_init(raw_spinlock_t *lock , char const *name , struct lock_class_key *key ) ;
2210#line 22 "include/linux/spinlock_api_smp.h"
2211extern void _raw_spin_lock(raw_spinlock_t *lock ) __attribute__((__section__(".spinlock.text"))) ;
2212#line 32
2213extern unsigned long _raw_spin_lock_irqsave(raw_spinlock_t *lock ) __attribute__((__section__(".spinlock.text"))) ;
2214#line 39
2215extern void _raw_spin_unlock(raw_spinlock_t *lock ) __attribute__((__section__(".spinlock.text"))) ;
2216#line 42
2217extern void _raw_spin_unlock_irqrestore(raw_spinlock_t *lock , unsigned long flags ) __attribute__((__section__(".spinlock.text"))) ;
2218#line 272 "include/linux/spinlock.h"
2219__inline static raw_spinlock_t *spinlock_check(spinlock_t *lock ) __attribute__((__no_instrument_function__)) ;
2220#line 272 "include/linux/spinlock.h"
2221__inline static raw_spinlock_t *spinlock_check(spinlock_t *lock )
2222{
2223
2224 {
2225#line 274
2226 return ((struct raw_spinlock *)lock);
2227}
2228}
2229#line 283
2230__inline static void spin_lock(spinlock_t *lock ) __attribute__((__no_instrument_function__)) ;
2231#line 283 "include/linux/spinlock.h"
2232__inline static void spin_lock(spinlock_t *lock )
2233{ struct raw_spinlock *__cil_tmp2 ;
2234
2235 {
2236 {
2237#line 285
2238 __cil_tmp2 = (struct raw_spinlock *)lock;
2239#line 285
2240 _raw_spin_lock(__cil_tmp2);
2241 }
2242#line 286
2243 return;
2244}
2245}
2246#line 323
2247__inline static void spin_unlock(spinlock_t *lock ) __attribute__((__no_instrument_function__)) ;
2248#line 323 "include/linux/spinlock.h"
2249__inline static void spin_unlock(spinlock_t *lock )
2250{ struct raw_spinlock *__cil_tmp2 ;
2251
2252 {
2253 {
2254#line 325
2255 __cil_tmp2 = (struct raw_spinlock *)lock;
2256#line 325
2257 _raw_spin_unlock(__cil_tmp2);
2258 }
2259#line 326
2260 return;
2261}
2262}
2263#line 338
2264__inline static void spin_unlock_irqrestore(spinlock_t *lock , unsigned long flags ) __attribute__((__no_instrument_function__)) ;
2265#line 338 "include/linux/spinlock.h"
2266__inline static void spin_unlock_irqrestore(spinlock_t *lock , unsigned long flags )
2267{ struct raw_spinlock *__cil_tmp5 ;
2268
2269 {
2270 {
2271#line 340
2272 while (1) {
2273 while_continue: ;
2274 {
2275#line 340
2276 __cil_tmp5 = (struct raw_spinlock *)lock;
2277#line 340
2278 _raw_spin_unlock_irqrestore(__cil_tmp5, flags);
2279 }
2280#line 340
2281 goto while_break;
2282 }
2283 while_break: ;
2284 }
2285#line 341
2286 return;
2287}
2288}
2289#line 152 "include/linux/mutex.h"
2290void mutex_lock(struct mutex *lock ) ;
2291#line 153
2292int __attribute__((__warn_unused_result__)) mutex_lock_interruptible(struct mutex *lock ) ;
2293#line 154
2294int __attribute__((__warn_unused_result__)) mutex_lock_killable(struct mutex *lock ) ;
2295#line 168
2296int mutex_trylock(struct mutex *lock ) ;
2297#line 169
2298void mutex_unlock(struct mutex *lock ) ;
2299#line 170
2300int atomic_dec_and_mutex_lock(atomic_t *cnt , struct mutex *lock ) ;
2301#line 138 "include/linux/ioport.h"
2302extern struct resource iomem_resource ;
2303#line 208
2304extern struct resource *__devm_request_region(struct device *dev , struct resource *parent ,
2305 resource_size_t start , resource_size_t n ,
2306 char const *name ) ;
2307#line 82 "include/linux/jiffies.h"
2308extern unsigned long volatile jiffies __attribute__((__section__(".data"))) ;
2309#line 53 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/io.h"
2310__inline static unsigned char readb(void const volatile *addr ) __attribute__((__no_instrument_function__)) ;
2311#line 53 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/io.h"
2312__inline static unsigned char readb(void const volatile *addr )
2313{ unsigned char ret ;
2314 unsigned char volatile *__cil_tmp3 ;
2315
2316 {
2317#line 53
2318 __cil_tmp3 = (unsigned char volatile *)addr;
2319#line 53
2320 __asm__ volatile ("mov"
2321 "b"
2322 " %1,%0": "=q" (ret): "m" (*__cil_tmp3): "memory");
2323#line 53
2324 return (ret);
2325}
2326}
2327#line 61
2328__inline static void writeb(unsigned char val , void volatile *addr ) __attribute__((__no_instrument_function__)) ;
2329#line 61 "/home/zakharov/launch/inst/current/envs/linux-3.4/linux-3.4/arch/x86/include/asm/io.h"
2330__inline static void writeb(unsigned char val , void volatile *addr )
2331{ unsigned char volatile *__cil_tmp3 ;
2332
2333 {
2334#line 61
2335 __cil_tmp3 = (unsigned char volatile *)addr;
2336#line 61
2337 __asm__ volatile ("mov"
2338 "b"
2339 " %0,%1": : "q" (val), "m" (*__cil_tmp3): "memory");
2340#line 61
2341 return;
2342}
2343}
2344#line 46 "include/linux/delay.h"
2345extern void msleep(unsigned int msecs ) ;
2346#line 189 "include/linux/interrupt.h"
2347extern int __attribute__((__warn_unused_result__)) devm_request_threaded_irq(struct device *dev ,
2348 unsigned int irq ,
2349 irqreturn_t (*handler)(int ,
2350 void * ) ,
2351 irqreturn_t (*thread_fn)(int ,
2352 void * ) ,
2353 unsigned long irqflags ,
2354 char const *devname ,
2355 void *dev_id ) ;
2356#line 195
2357__inline static int __attribute__((__warn_unused_result__)) devm_request_irq(struct device *dev ,
2358 unsigned int irq ,
2359 irqreturn_t (*handler)(int ,
2360 void * ) ,
2361 unsigned long irqflags ,
2362 char const *devname ,
2363 void *dev_id ) __attribute__((__no_instrument_function__)) ;
2364#line 195 "include/linux/interrupt.h"
2365__inline static int __attribute__((__warn_unused_result__)) devm_request_irq(struct device *dev ,
2366 unsigned int irq ,
2367 irqreturn_t (*handler)(int ,
2368 void * ) ,
2369 unsigned long irqflags ,
2370 char const *devname ,
2371 void *dev_id )
2372{ int tmp ;
2373 void *__cil_tmp8 ;
2374 irqreturn_t (*__cil_tmp9)(int , void * ) ;
2375
2376 {
2377 {
2378#line 199
2379 __cil_tmp8 = (void *)0;
2380#line 199
2381 __cil_tmp9 = (irqreturn_t (*)(int , void * ))__cil_tmp8;
2382#line 199
2383 tmp = (int )devm_request_threaded_irq(dev, irq, handler, __cil_tmp9, irqflags, devname,
2384 dev_id);
2385 }
2386#line 199
2387 return (tmp);
2388}
2389}
2390#line 110 "include/linux/rtc.h"
2391extern int rtc_valid_tm(struct rtc_time *tm ) ;
2392#line 112
2393extern void rtc_time_to_tm(unsigned long time , struct rtc_time *tm ) ;
2394#line 140 "include/linux/sysfs.h"
2395extern int __attribute__((__warn_unused_result__)) sysfs_create_bin_file(struct kobject *kobj ,
2396 struct bin_attribute const *attr ) ;
2397#line 142
2398extern void sysfs_remove_bin_file(struct kobject *kobj , struct bin_attribute const *attr ) ;
2399#line 553 "include/linux/device.h"
2400extern void *devm_kzalloc(struct device *dev , size_t size , gfp_t gfp ) ;
2401#line 792
2402extern void *dev_get_drvdata(struct device const *dev ) ;
2403#line 793
2404extern int dev_set_drvdata(struct device *dev , void *data ) ;
2405#line 891
2406extern int ( dev_err)(struct device const *dev , char const *fmt
2407 , ...) ;
2408#line 893
2409extern int ( dev_warn)(struct device const *dev , char const *fmt
2410 , ...) ;
2411#line 221 "include/linux/rtc.h"
2412extern struct rtc_device *rtc_device_register(char const *name , struct device *dev ,
2413 struct rtc_class_ops const *ops ,
2414 struct module *owner ) ;
2415#line 225
2416extern void rtc_device_unregister(struct rtc_device *rtc ) ;
2417#line 237
2418extern void rtc_update_irq(struct rtc_device *rtc , unsigned long num , unsigned long events ) ;
2419#line 46 "include/linux/platform_device.h"
2420extern struct resource *platform_get_resource(struct platform_device * , unsigned int ,
2421 unsigned int ) ;
2422#line 47
2423extern int platform_get_irq(struct platform_device * , unsigned int ) ;
2424#line 174
2425extern int platform_driver_register(struct platform_driver * ) ;
2426#line 175
2427extern void platform_driver_unregister(struct platform_driver * ) ;
2428#line 183
2429__inline static void *platform_get_drvdata(struct platform_device const *pdev ) __attribute__((__no_instrument_function__)) ;
2430#line 183 "include/linux/platform_device.h"
2431__inline static void *platform_get_drvdata(struct platform_device const *pdev )
2432{ void *tmp ;
2433 unsigned long __cil_tmp3 ;
2434 unsigned long __cil_tmp4 ;
2435 struct device const *__cil_tmp5 ;
2436
2437 {
2438 {
2439#line 185
2440 __cil_tmp3 = (unsigned long )pdev;
2441#line 185
2442 __cil_tmp4 = __cil_tmp3 + 16;
2443#line 185
2444 __cil_tmp5 = (struct device const *)__cil_tmp4;
2445#line 185
2446 tmp = dev_get_drvdata(__cil_tmp5);
2447 }
2448#line 185
2449 return (tmp);
2450}
2451}
2452#line 188
2453__inline static void platform_set_drvdata(struct platform_device *pdev , void *data ) __attribute__((__no_instrument_function__)) ;
2454#line 188 "include/linux/platform_device.h"
2455__inline static void platform_set_drvdata(struct platform_device *pdev , void *data )
2456{ unsigned long __cil_tmp3 ;
2457 unsigned long __cil_tmp4 ;
2458 struct device *__cil_tmp5 ;
2459
2460 {
2461 {
2462#line 190
2463 __cil_tmp3 = (unsigned long )pdev;
2464#line 190
2465 __cil_tmp4 = __cil_tmp3 + 16;
2466#line 190
2467 __cil_tmp5 = (struct device *)__cil_tmp4;
2468#line 190
2469 dev_set_drvdata(__cil_tmp5, data);
2470 }
2471#line 191
2472 return;
2473}
2474}
2475#line 61 "include/linux/io.h"
2476extern void *devm_ioremap(struct device *dev , resource_size_t offset , unsigned long size ) ;
2477#line 26 "include/linux/export.h"
2478extern struct module __this_module ;
2479#line 67 "include/linux/module.h"
2480int init_module(void) ;
2481#line 68
2482void cleanup_module(void) ;
2483#line 78 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
2484static int stk17ta8_rtc_set_time(struct device *dev , struct rtc_time *tm )
2485{ struct platform_device *pdev ;
2486 struct device const *__mptr ;
2487 struct rtc_plat_data *pdata ;
2488 void *tmp ;
2489 void *ioaddr ;
2490 u8 flags ;
2491 unsigned char tmp___0 ;
2492 unsigned char tmp___1 ;
2493 unsigned char tmp___2 ;
2494 unsigned char tmp___3 ;
2495 unsigned char tmp___4 ;
2496 unsigned char tmp___5 ;
2497 unsigned char tmp___6 ;
2498 unsigned char tmp___7 ;
2499 struct platform_device *__cil_tmp17 ;
2500 unsigned long __cil_tmp18 ;
2501 unsigned long __cil_tmp19 ;
2502 struct device *__cil_tmp20 ;
2503 unsigned int __cil_tmp21 ;
2504 char *__cil_tmp22 ;
2505 char *__cil_tmp23 ;
2506 struct platform_device const *__cil_tmp24 ;
2507 unsigned long __cil_tmp25 ;
2508 unsigned long __cil_tmp26 ;
2509 unsigned long __cil_tmp27 ;
2510 unsigned long __cil_tmp28 ;
2511 void *__cil_tmp29 ;
2512 void *__cil_tmp30 ;
2513 void const volatile *__cil_tmp31 ;
2514 int __cil_tmp32 ;
2515 int __cil_tmp33 ;
2516 unsigned char __cil_tmp34 ;
2517 unsigned long __cil_tmp35 ;
2518 unsigned long __cil_tmp36 ;
2519 void *__cil_tmp37 ;
2520 void *__cil_tmp38 ;
2521 void volatile *__cil_tmp39 ;
2522 unsigned long __cil_tmp40 ;
2523 unsigned long __cil_tmp41 ;
2524 int __cil_tmp42 ;
2525 int __cil_tmp43 ;
2526 unsigned int __cil_tmp44 ;
2527 void *__cil_tmp45 ;
2528 void volatile *__cil_tmp46 ;
2529 unsigned long __cil_tmp47 ;
2530 unsigned long __cil_tmp48 ;
2531 int __cil_tmp49 ;
2532 int __cil_tmp50 ;
2533 unsigned int __cil_tmp51 ;
2534 void *__cil_tmp52 ;
2535 void volatile *__cil_tmp53 ;
2536 unsigned long __cil_tmp54 ;
2537 unsigned long __cil_tmp55 ;
2538 int __cil_tmp56 ;
2539 unsigned int __cil_tmp57 ;
2540 int __cil_tmp58 ;
2541 int __cil_tmp59 ;
2542 unsigned char __cil_tmp60 ;
2543 void *__cil_tmp61 ;
2544 void volatile *__cil_tmp62 ;
2545 unsigned long __cil_tmp63 ;
2546 unsigned long __cil_tmp64 ;
2547 int __cil_tmp65 ;
2548 unsigned int __cil_tmp66 ;
2549 void *__cil_tmp67 ;
2550 void volatile *__cil_tmp68 ;
2551 unsigned long __cil_tmp69 ;
2552 unsigned long __cil_tmp70 ;
2553 int __cil_tmp71 ;
2554 unsigned int __cil_tmp72 ;
2555 void *__cil_tmp73 ;
2556 void volatile *__cil_tmp74 ;
2557 unsigned long __cil_tmp75 ;
2558 unsigned long __cil_tmp76 ;
2559 int __cil_tmp77 ;
2560 unsigned int __cil_tmp78 ;
2561 void *__cil_tmp79 ;
2562 void volatile *__cil_tmp80 ;
2563 int __cil_tmp81 ;
2564 unsigned int __cil_tmp82 ;
2565 int __cil_tmp83 ;
2566 int __cil_tmp84 ;
2567 unsigned char __cil_tmp85 ;
2568 void *__cil_tmp86 ;
2569 void volatile *__cil_tmp87 ;
2570 unsigned long __cil_tmp88 ;
2571 unsigned long __cil_tmp89 ;
2572 int __cil_tmp90 ;
2573 int __cil_tmp91 ;
2574 int __cil_tmp92 ;
2575 unsigned int __cil_tmp93 ;
2576 void *__cil_tmp94 ;
2577 void volatile *__cil_tmp95 ;
2578 int __cil_tmp96 ;
2579 int __cil_tmp97 ;
2580 unsigned char __cil_tmp98 ;
2581 unsigned long __cil_tmp99 ;
2582 unsigned long __cil_tmp100 ;
2583 void *__cil_tmp101 ;
2584 void *__cil_tmp102 ;
2585 void volatile *__cil_tmp103 ;
2586
2587 {
2588 {
2589#line 80
2590 __mptr = (struct device const *)dev;
2591#line 80
2592 __cil_tmp17 = (struct platform_device *)0;
2593#line 80
2594 __cil_tmp18 = (unsigned long )__cil_tmp17;
2595#line 80
2596 __cil_tmp19 = __cil_tmp18 + 16;
2597#line 80
2598 __cil_tmp20 = (struct device *)__cil_tmp19;
2599#line 80
2600 __cil_tmp21 = (unsigned int )__cil_tmp20;
2601#line 80
2602 __cil_tmp22 = (char *)__mptr;
2603#line 80
2604 __cil_tmp23 = __cil_tmp22 - __cil_tmp21;
2605#line 80
2606 pdev = (struct platform_device *)__cil_tmp23;
2607#line 81
2608 __cil_tmp24 = (struct platform_device const *)pdev;
2609#line 81
2610 tmp = platform_get_drvdata(__cil_tmp24);
2611#line 81
2612 pdata = (struct rtc_plat_data *)tmp;
2613#line 82
2614 __cil_tmp25 = (unsigned long )pdata;
2615#line 82
2616 __cil_tmp26 = __cil_tmp25 + 8;
2617#line 82
2618 ioaddr = *((void **)__cil_tmp26);
2619#line 85
2620 __cil_tmp27 = (unsigned long )pdata;
2621#line 85
2622 __cil_tmp28 = __cil_tmp27 + 8;
2623#line 85
2624 __cil_tmp29 = *((void **)__cil_tmp28);
2625#line 85
2626 __cil_tmp30 = __cil_tmp29 + 131056;
2627#line 85
2628 __cil_tmp31 = (void const volatile *)__cil_tmp30;
2629#line 85
2630 flags = readb(__cil_tmp31);
2631#line 86
2632 __cil_tmp32 = (int )flags;
2633#line 86
2634 __cil_tmp33 = __cil_tmp32 | 2;
2635#line 86
2636 __cil_tmp34 = (unsigned char )__cil_tmp33;
2637#line 86
2638 __cil_tmp35 = (unsigned long )pdata;
2639#line 86
2640 __cil_tmp36 = __cil_tmp35 + 8;
2641#line 86
2642 __cil_tmp37 = *((void **)__cil_tmp36);
2643#line 86
2644 __cil_tmp38 = __cil_tmp37 + 131056;
2645#line 86
2646 __cil_tmp39 = (void volatile *)__cil_tmp38;
2647#line 86
2648 writeb(__cil_tmp34, __cil_tmp39);
2649#line 88
2650 __cil_tmp40 = (unsigned long )tm;
2651#line 88
2652 __cil_tmp41 = __cil_tmp40 + 20;
2653#line 88
2654 __cil_tmp42 = *((int *)__cil_tmp41);
2655#line 88
2656 __cil_tmp43 = __cil_tmp42 % 100;
2657#line 88
2658 __cil_tmp44 = (unsigned int )__cil_tmp43;
2659#line 88
2660 tmp___0 = bin2bcd(__cil_tmp44);
2661#line 88
2662 __cil_tmp45 = ioaddr + 131071;
2663#line 88
2664 __cil_tmp46 = (void volatile *)__cil_tmp45;
2665#line 88
2666 writeb(tmp___0, __cil_tmp46);
2667#line 89
2668 __cil_tmp47 = (unsigned long )tm;
2669#line 89
2670 __cil_tmp48 = __cil_tmp47 + 16;
2671#line 89
2672 __cil_tmp49 = *((int *)__cil_tmp48);
2673#line 89
2674 __cil_tmp50 = __cil_tmp49 + 1;
2675#line 89
2676 __cil_tmp51 = (unsigned int )__cil_tmp50;
2677#line 89
2678 tmp___1 = bin2bcd(__cil_tmp51);
2679#line 89
2680 __cil_tmp52 = ioaddr + 131070;
2681#line 89
2682 __cil_tmp53 = (void volatile *)__cil_tmp52;
2683#line 89
2684 writeb(tmp___1, __cil_tmp53);
2685#line 90
2686 __cil_tmp54 = (unsigned long )tm;
2687#line 90
2688 __cil_tmp55 = __cil_tmp54 + 24;
2689#line 90
2690 __cil_tmp56 = *((int *)__cil_tmp55);
2691#line 90
2692 __cil_tmp57 = (unsigned int )__cil_tmp56;
2693#line 90
2694 tmp___2 = bin2bcd(__cil_tmp57);
2695#line 90
2696 __cil_tmp58 = (int )tmp___2;
2697#line 90
2698 __cil_tmp59 = __cil_tmp58 & 7;
2699#line 90
2700 __cil_tmp60 = (unsigned char )__cil_tmp59;
2701#line 90
2702 __cil_tmp61 = ioaddr + 131068;
2703#line 90
2704 __cil_tmp62 = (void volatile *)__cil_tmp61;
2705#line 90
2706 writeb(__cil_tmp60, __cil_tmp62);
2707#line 91
2708 __cil_tmp63 = (unsigned long )tm;
2709#line 91
2710 __cil_tmp64 = __cil_tmp63 + 12;
2711#line 91
2712 __cil_tmp65 = *((int *)__cil_tmp64);
2713#line 91
2714 __cil_tmp66 = (unsigned int )__cil_tmp65;
2715#line 91
2716 tmp___3 = bin2bcd(__cil_tmp66);
2717#line 91
2718 __cil_tmp67 = ioaddr + 131069;
2719#line 91
2720 __cil_tmp68 = (void volatile *)__cil_tmp67;
2721#line 91
2722 writeb(tmp___3, __cil_tmp68);
2723#line 92
2724 __cil_tmp69 = (unsigned long )tm;
2725#line 92
2726 __cil_tmp70 = __cil_tmp69 + 8;
2727#line 92
2728 __cil_tmp71 = *((int *)__cil_tmp70);
2729#line 92
2730 __cil_tmp72 = (unsigned int )__cil_tmp71;
2731#line 92
2732 tmp___4 = bin2bcd(__cil_tmp72);
2733#line 92
2734 __cil_tmp73 = ioaddr + 131067;
2735#line 92
2736 __cil_tmp74 = (void volatile *)__cil_tmp73;
2737#line 92
2738 writeb(tmp___4, __cil_tmp74);
2739#line 93
2740 __cil_tmp75 = (unsigned long )tm;
2741#line 93
2742 __cil_tmp76 = __cil_tmp75 + 4;
2743#line 93
2744 __cil_tmp77 = *((int *)__cil_tmp76);
2745#line 93
2746 __cil_tmp78 = (unsigned int )__cil_tmp77;
2747#line 93
2748 tmp___5 = bin2bcd(__cil_tmp78);
2749#line 93
2750 __cil_tmp79 = ioaddr + 131066;
2751#line 93
2752 __cil_tmp80 = (void volatile *)__cil_tmp79;
2753#line 93
2754 writeb(tmp___5, __cil_tmp80);
2755#line 94
2756 __cil_tmp81 = *((int *)tm);
2757#line 94
2758 __cil_tmp82 = (unsigned int )__cil_tmp81;
2759#line 94
2760 tmp___6 = bin2bcd(__cil_tmp82);
2761#line 94
2762 __cil_tmp83 = (int )tmp___6;
2763#line 94
2764 __cil_tmp84 = __cil_tmp83 & 127;
2765#line 94
2766 __cil_tmp85 = (unsigned char )__cil_tmp84;
2767#line 94
2768 __cil_tmp86 = ioaddr + 131065;
2769#line 94
2770 __cil_tmp87 = (void volatile *)__cil_tmp86;
2771#line 94
2772 writeb(__cil_tmp85, __cil_tmp87);
2773#line 95
2774 __cil_tmp88 = (unsigned long )tm;
2775#line 95
2776 __cil_tmp89 = __cil_tmp88 + 20;
2777#line 95
2778 __cil_tmp90 = *((int *)__cil_tmp89);
2779#line 95
2780 __cil_tmp91 = __cil_tmp90 + 1900;
2781#line 95
2782 __cil_tmp92 = __cil_tmp91 / 100;
2783#line 95
2784 __cil_tmp93 = (unsigned int )__cil_tmp92;
2785#line 95
2786 tmp___7 = bin2bcd(__cil_tmp93);
2787#line 95
2788 __cil_tmp94 = ioaddr + 131057;
2789#line 95
2790 __cil_tmp95 = (void volatile *)__cil_tmp94;
2791#line 95
2792 writeb(tmp___7, __cil_tmp95);
2793#line 97
2794 __cil_tmp96 = (int )flags;
2795#line 97
2796 __cil_tmp97 = __cil_tmp96 & -3;
2797#line 97
2798 __cil_tmp98 = (unsigned char )__cil_tmp97;
2799#line 97
2800 __cil_tmp99 = (unsigned long )pdata;
2801#line 97
2802 __cil_tmp100 = __cil_tmp99 + 8;
2803#line 97
2804 __cil_tmp101 = *((void **)__cil_tmp100);
2805#line 97
2806 __cil_tmp102 = __cil_tmp101 + 131056;
2807#line 97
2808 __cil_tmp103 = (void volatile *)__cil_tmp102;
2809#line 97
2810 writeb(__cil_tmp98, __cil_tmp103);
2811 }
2812#line 98
2813 return (0);
2814}
2815}
2816#line 101 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
2817static int stk17ta8_rtc_read_time(struct device *dev , struct rtc_time *tm )
2818{ struct platform_device *pdev ;
2819 struct device const *__mptr ;
2820 struct rtc_plat_data *pdata ;
2821 void *tmp ;
2822 void *ioaddr ;
2823 unsigned int year ;
2824 unsigned int month ;
2825 unsigned int day ;
2826 unsigned int hour ;
2827 unsigned int minute ;
2828 unsigned int second ;
2829 unsigned int week ;
2830 unsigned int century ;
2831 u8 flags ;
2832 unsigned char tmp___0 ;
2833 unsigned char tmp___1 ;
2834 unsigned char tmp___2 ;
2835 unsigned char tmp___3 ;
2836 unsigned char tmp___4 ;
2837 unsigned char tmp___5 ;
2838 unsigned char tmp___6 ;
2839 unsigned char tmp___7 ;
2840 unsigned int tmp___8 ;
2841 unsigned int tmp___9 ;
2842 unsigned int tmp___10 ;
2843 unsigned int tmp___11 ;
2844 unsigned int tmp___12 ;
2845 unsigned int tmp___13 ;
2846 unsigned int tmp___14 ;
2847 unsigned int tmp___15 ;
2848 int tmp___16 ;
2849 struct platform_device *__cil_tmp34 ;
2850 unsigned long __cil_tmp35 ;
2851 unsigned long __cil_tmp36 ;
2852 struct device *__cil_tmp37 ;
2853 unsigned int __cil_tmp38 ;
2854 char *__cil_tmp39 ;
2855 char *__cil_tmp40 ;
2856 struct platform_device const *__cil_tmp41 ;
2857 unsigned long __cil_tmp42 ;
2858 unsigned long __cil_tmp43 ;
2859 unsigned long __cil_tmp44 ;
2860 unsigned long __cil_tmp45 ;
2861 unsigned long __cil_tmp46 ;
2862 unsigned long __cil_tmp47 ;
2863 unsigned long __cil_tmp48 ;
2864 unsigned long __cil_tmp49 ;
2865 unsigned long __cil_tmp50 ;
2866 unsigned long __cil_tmp51 ;
2867 void *__cil_tmp52 ;
2868 void *__cil_tmp53 ;
2869 void const volatile *__cil_tmp54 ;
2870 int __cil_tmp55 ;
2871 int __cil_tmp56 ;
2872 unsigned char __cil_tmp57 ;
2873 void *__cil_tmp58 ;
2874 void volatile *__cil_tmp59 ;
2875 void *__cil_tmp60 ;
2876 void const volatile *__cil_tmp61 ;
2877 int __cil_tmp62 ;
2878 int __cil_tmp63 ;
2879 void *__cil_tmp64 ;
2880 void const volatile *__cil_tmp65 ;
2881 void *__cil_tmp66 ;
2882 void const volatile *__cil_tmp67 ;
2883 void *__cil_tmp68 ;
2884 void const volatile *__cil_tmp69 ;
2885 void *__cil_tmp70 ;
2886 void const volatile *__cil_tmp71 ;
2887 int __cil_tmp72 ;
2888 int __cil_tmp73 ;
2889 void *__cil_tmp74 ;
2890 void const volatile *__cil_tmp75 ;
2891 void *__cil_tmp76 ;
2892 void const volatile *__cil_tmp77 ;
2893 void *__cil_tmp78 ;
2894 void const volatile *__cil_tmp79 ;
2895 int __cil_tmp80 ;
2896 int __cil_tmp81 ;
2897 unsigned char __cil_tmp82 ;
2898 void *__cil_tmp83 ;
2899 void volatile *__cil_tmp84 ;
2900 unsigned char __cil_tmp85 ;
2901 unsigned char __cil_tmp86 ;
2902 unsigned long __cil_tmp87 ;
2903 unsigned long __cil_tmp88 ;
2904 unsigned char __cil_tmp89 ;
2905 unsigned long __cil_tmp90 ;
2906 unsigned long __cil_tmp91 ;
2907 unsigned char __cil_tmp92 ;
2908 unsigned long __cil_tmp93 ;
2909 unsigned long __cil_tmp94 ;
2910 unsigned char __cil_tmp95 ;
2911 unsigned long __cil_tmp96 ;
2912 unsigned long __cil_tmp97 ;
2913 unsigned char __cil_tmp98 ;
2914 unsigned long __cil_tmp99 ;
2915 unsigned long __cil_tmp100 ;
2916 unsigned int __cil_tmp101 ;
2917 unsigned char __cil_tmp102 ;
2918 unsigned char __cil_tmp103 ;
2919 unsigned long __cil_tmp104 ;
2920 unsigned long __cil_tmp105 ;
2921 unsigned int __cil_tmp106 ;
2922 unsigned int __cil_tmp107 ;
2923 unsigned int __cil_tmp108 ;
2924 struct device const *__cil_tmp109 ;
2925
2926 {
2927 {
2928#line 103
2929 __mptr = (struct device const *)dev;
2930#line 103
2931 __cil_tmp34 = (struct platform_device *)0;
2932#line 103
2933 __cil_tmp35 = (unsigned long )__cil_tmp34;
2934#line 103
2935 __cil_tmp36 = __cil_tmp35 + 16;
2936#line 103
2937 __cil_tmp37 = (struct device *)__cil_tmp36;
2938#line 103
2939 __cil_tmp38 = (unsigned int )__cil_tmp37;
2940#line 103
2941 __cil_tmp39 = (char *)__mptr;
2942#line 103
2943 __cil_tmp40 = __cil_tmp39 - __cil_tmp38;
2944#line 103
2945 pdev = (struct platform_device *)__cil_tmp40;
2946#line 104
2947 __cil_tmp41 = (struct platform_device const *)pdev;
2948#line 104
2949 tmp = platform_get_drvdata(__cil_tmp41);
2950#line 104
2951 pdata = (struct rtc_plat_data *)tmp;
2952#line 105
2953 __cil_tmp42 = (unsigned long )pdata;
2954#line 105
2955 __cil_tmp43 = __cil_tmp42 + 8;
2956#line 105
2957 ioaddr = *((void **)__cil_tmp43);
2958 }
2959 {
2960#line 111
2961 __cil_tmp44 = (unsigned long )jiffies;
2962#line 111
2963 __cil_tmp45 = (unsigned long )pdata;
2964#line 111
2965 __cil_tmp46 = __cil_tmp45 + 16;
2966#line 111
2967 __cil_tmp47 = *((unsigned long *)__cil_tmp46);
2968#line 111
2969 if (__cil_tmp47 == __cil_tmp44) {
2970 {
2971#line 112
2972 msleep(1U);
2973 }
2974 } else {
2975
2976 }
2977 }
2978 {
2979#line 113
2980 __cil_tmp48 = (unsigned long )pdata;
2981#line 113
2982 __cil_tmp49 = __cil_tmp48 + 16;
2983#line 113
2984 *((unsigned long *)__cil_tmp49) = (unsigned long )jiffies;
2985#line 115
2986 __cil_tmp50 = (unsigned long )pdata;
2987#line 115
2988 __cil_tmp51 = __cil_tmp50 + 8;
2989#line 115
2990 __cil_tmp52 = *((void **)__cil_tmp51);
2991#line 115
2992 __cil_tmp53 = __cil_tmp52 + 131056;
2993#line 115
2994 __cil_tmp54 = (void const volatile *)__cil_tmp53;
2995#line 115
2996 flags = readb(__cil_tmp54);
2997#line 116
2998 __cil_tmp55 = (int )flags;
2999#line 116
3000 __cil_tmp56 = __cil_tmp55 | 1;
3001#line 116
3002 __cil_tmp57 = (unsigned char )__cil_tmp56;
3003#line 116
3004 __cil_tmp58 = ioaddr + 131056;
3005#line 116
3006 __cil_tmp59 = (void volatile *)__cil_tmp58;
3007#line 116
3008 writeb(__cil_tmp57, __cil_tmp59);
3009#line 117
3010 __cil_tmp60 = ioaddr + 131065;
3011#line 117
3012 __cil_tmp61 = (void const volatile *)__cil_tmp60;
3013#line 117
3014 tmp___0 = readb(__cil_tmp61);
3015#line 117
3016 __cil_tmp62 = (int )tmp___0;
3017#line 117
3018 __cil_tmp63 = __cil_tmp62 & 127;
3019#line 117
3020 second = (unsigned int )__cil_tmp63;
3021#line 118
3022 __cil_tmp64 = ioaddr + 131066;
3023#line 118
3024 __cil_tmp65 = (void const volatile *)__cil_tmp64;
3025#line 118
3026 tmp___1 = readb(__cil_tmp65);
3027#line 118
3028 minute = (unsigned int )tmp___1;
3029#line 119
3030 __cil_tmp66 = ioaddr + 131067;
3031#line 119
3032 __cil_tmp67 = (void const volatile *)__cil_tmp66;
3033#line 119
3034 tmp___2 = readb(__cil_tmp67);
3035#line 119
3036 hour = (unsigned int )tmp___2;
3037#line 120
3038 __cil_tmp68 = ioaddr + 131069;
3039#line 120
3040 __cil_tmp69 = (void const volatile *)__cil_tmp68;
3041#line 120
3042 tmp___3 = readb(__cil_tmp69);
3043#line 120
3044 day = (unsigned int )tmp___3;
3045#line 121
3046 __cil_tmp70 = ioaddr + 131068;
3047#line 121
3048 __cil_tmp71 = (void const volatile *)__cil_tmp70;
3049#line 121
3050 tmp___4 = readb(__cil_tmp71);
3051#line 121
3052 __cil_tmp72 = (int )tmp___4;
3053#line 121
3054 __cil_tmp73 = __cil_tmp72 & 7;
3055#line 121
3056 week = (unsigned int )__cil_tmp73;
3057#line 122
3058 __cil_tmp74 = ioaddr + 131070;
3059#line 122
3060 __cil_tmp75 = (void const volatile *)__cil_tmp74;
3061#line 122
3062 tmp___5 = readb(__cil_tmp75);
3063#line 122
3064 month = (unsigned int )tmp___5;
3065#line 123
3066 __cil_tmp76 = ioaddr + 131071;
3067#line 123
3068 __cil_tmp77 = (void const volatile *)__cil_tmp76;
3069#line 123
3070 tmp___6 = readb(__cil_tmp77);
3071#line 123
3072 year = (unsigned int )tmp___6;
3073#line 124
3074 __cil_tmp78 = ioaddr + 131057;
3075#line 124
3076 __cil_tmp79 = (void const volatile *)__cil_tmp78;
3077#line 124
3078 tmp___7 = readb(__cil_tmp79);
3079#line 124
3080 century = (unsigned int )tmp___7;
3081#line 125
3082 __cil_tmp80 = (int )flags;
3083#line 125
3084 __cil_tmp81 = __cil_tmp80 & -2;
3085#line 125
3086 __cil_tmp82 = (unsigned char )__cil_tmp81;
3087#line 125
3088 __cil_tmp83 = ioaddr + 131056;
3089#line 125
3090 __cil_tmp84 = (void volatile *)__cil_tmp83;
3091#line 125
3092 writeb(__cil_tmp82, __cil_tmp84);
3093#line 126
3094 __cil_tmp85 = (unsigned char )second;
3095#line 126
3096 tmp___8 = bcd2bin(__cil_tmp85);
3097#line 126
3098 *((int *)tm) = (int )tmp___8;
3099#line 127
3100 __cil_tmp86 = (unsigned char )minute;
3101#line 127
3102 tmp___9 = bcd2bin(__cil_tmp86);
3103#line 127
3104 __cil_tmp87 = (unsigned long )tm;
3105#line 127
3106 __cil_tmp88 = __cil_tmp87 + 4;
3107#line 127
3108 *((int *)__cil_tmp88) = (int )tmp___9;
3109#line 128
3110 __cil_tmp89 = (unsigned char )hour;
3111#line 128
3112 tmp___10 = bcd2bin(__cil_tmp89);
3113#line 128
3114 __cil_tmp90 = (unsigned long )tm;
3115#line 128
3116 __cil_tmp91 = __cil_tmp90 + 8;
3117#line 128
3118 *((int *)__cil_tmp91) = (int )tmp___10;
3119#line 129
3120 __cil_tmp92 = (unsigned char )day;
3121#line 129
3122 tmp___11 = bcd2bin(__cil_tmp92);
3123#line 129
3124 __cil_tmp93 = (unsigned long )tm;
3125#line 129
3126 __cil_tmp94 = __cil_tmp93 + 12;
3127#line 129
3128 *((int *)__cil_tmp94) = (int )tmp___11;
3129#line 130
3130 __cil_tmp95 = (unsigned char )week;
3131#line 130
3132 tmp___12 = bcd2bin(__cil_tmp95);
3133#line 130
3134 __cil_tmp96 = (unsigned long )tm;
3135#line 130
3136 __cil_tmp97 = __cil_tmp96 + 24;
3137#line 130
3138 *((int *)__cil_tmp97) = (int )tmp___12;
3139#line 131
3140 __cil_tmp98 = (unsigned char )month;
3141#line 131
3142 tmp___13 = bcd2bin(__cil_tmp98);
3143#line 131
3144 __cil_tmp99 = (unsigned long )tm;
3145#line 131
3146 __cil_tmp100 = __cil_tmp99 + 16;
3147#line 131
3148 __cil_tmp101 = tmp___13 - 1U;
3149#line 131
3150 *((int *)__cil_tmp100) = (int )__cil_tmp101;
3151#line 133
3152 __cil_tmp102 = (unsigned char )year;
3153#line 133
3154 tmp___14 = bcd2bin(__cil_tmp102);
3155#line 133
3156 __cil_tmp103 = (unsigned char )century;
3157#line 133
3158 tmp___15 = bcd2bin(__cil_tmp103);
3159#line 133
3160 __cil_tmp104 = (unsigned long )tm;
3161#line 133
3162 __cil_tmp105 = __cil_tmp104 + 20;
3163#line 133
3164 __cil_tmp106 = tmp___15 * 100U;
3165#line 133
3166 __cil_tmp107 = tmp___14 + __cil_tmp106;
3167#line 133
3168 __cil_tmp108 = __cil_tmp107 - 1900U;
3169#line 133
3170 *((int *)__cil_tmp105) = (int )__cil_tmp108;
3171#line 135
3172 tmp___16 = rtc_valid_tm(tm);
3173 }
3174#line 135
3175 if (tmp___16 < 0) {
3176 {
3177#line 136
3178 __cil_tmp109 = (struct device const *)dev;
3179#line 136
3180 dev_err(__cil_tmp109, "retrieved date/time is not valid.\n");
3181#line 137
3182 rtc_time_to_tm(0UL, tm);
3183 }
3184 } else {
3185
3186 }
3187#line 139
3188 return (0);
3189}
3190}
3191#line 142 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
3192static void stk17ta8_rtc_update_alarm(struct rtc_plat_data *pdata )
3193{ void *ioaddr ;
3194 unsigned long irqflags ;
3195 u8 flags ;
3196 raw_spinlock_t *tmp ;
3197 unsigned char tmp___0 ;
3198 int tmp___1 ;
3199 unsigned char tmp___2 ;
3200 int tmp___3 ;
3201 unsigned char tmp___4 ;
3202 int tmp___5 ;
3203 unsigned char tmp___6 ;
3204 int tmp___7 ;
3205 int tmp___8 ;
3206 unsigned long __cil_tmp17 ;
3207 unsigned long __cil_tmp18 ;
3208 unsigned long __cil_tmp19 ;
3209 unsigned long __cil_tmp20 ;
3210 spinlock_t *__cil_tmp21 ;
3211 void *__cil_tmp22 ;
3212 void const volatile *__cil_tmp23 ;
3213 int __cil_tmp24 ;
3214 int __cil_tmp25 ;
3215 unsigned char __cil_tmp26 ;
3216 void *__cil_tmp27 ;
3217 void volatile *__cil_tmp28 ;
3218 unsigned long __cil_tmp29 ;
3219 unsigned long __cil_tmp30 ;
3220 int __cil_tmp31 ;
3221 unsigned long __cil_tmp32 ;
3222 unsigned long __cil_tmp33 ;
3223 unsigned int __cil_tmp34 ;
3224 unsigned long __cil_tmp35 ;
3225 unsigned long __cil_tmp36 ;
3226 int __cil_tmp37 ;
3227 unsigned int __cil_tmp38 ;
3228 unsigned char __cil_tmp39 ;
3229 void *__cil_tmp40 ;
3230 void volatile *__cil_tmp41 ;
3231 unsigned long __cil_tmp42 ;
3232 unsigned long __cil_tmp43 ;
3233 int __cil_tmp44 ;
3234 unsigned long __cil_tmp45 ;
3235 unsigned long __cil_tmp46 ;
3236 unsigned int __cil_tmp47 ;
3237 unsigned long __cil_tmp48 ;
3238 unsigned long __cil_tmp49 ;
3239 int __cil_tmp50 ;
3240 unsigned int __cil_tmp51 ;
3241 unsigned char __cil_tmp52 ;
3242 void *__cil_tmp53 ;
3243 void volatile *__cil_tmp54 ;
3244 unsigned long __cil_tmp55 ;
3245 unsigned long __cil_tmp56 ;
3246 int __cil_tmp57 ;
3247 unsigned long __cil_tmp58 ;
3248 unsigned long __cil_tmp59 ;
3249 unsigned int __cil_tmp60 ;
3250 unsigned long __cil_tmp61 ;
3251 unsigned long __cil_tmp62 ;
3252 int __cil_tmp63 ;
3253 unsigned int __cil_tmp64 ;
3254 unsigned char __cil_tmp65 ;
3255 void *__cil_tmp66 ;
3256 void volatile *__cil_tmp67 ;
3257 unsigned long __cil_tmp68 ;
3258 unsigned long __cil_tmp69 ;
3259 int __cil_tmp70 ;
3260 unsigned long __cil_tmp71 ;
3261 unsigned long __cil_tmp72 ;
3262 unsigned int __cil_tmp73 ;
3263 unsigned long __cil_tmp74 ;
3264 unsigned long __cil_tmp75 ;
3265 int __cil_tmp76 ;
3266 unsigned int __cil_tmp77 ;
3267 unsigned char __cil_tmp78 ;
3268 void *__cil_tmp79 ;
3269 void volatile *__cil_tmp80 ;
3270 unsigned long __cil_tmp81 ;
3271 unsigned long __cil_tmp82 ;
3272 unsigned char __cil_tmp83 ;
3273 void *__cil_tmp84 ;
3274 void volatile *__cil_tmp85 ;
3275 void *__cil_tmp86 ;
3276 void const volatile *__cil_tmp87 ;
3277 int __cil_tmp88 ;
3278 int __cil_tmp89 ;
3279 unsigned char __cil_tmp90 ;
3280 void *__cil_tmp91 ;
3281 void volatile *__cil_tmp92 ;
3282 unsigned long __cil_tmp93 ;
3283 unsigned long __cil_tmp94 ;
3284 spinlock_t *__cil_tmp95 ;
3285
3286 {
3287#line 144
3288 __cil_tmp17 = (unsigned long )pdata;
3289#line 144
3290 __cil_tmp18 = __cil_tmp17 + 8;
3291#line 144
3292 ioaddr = *((void **)__cil_tmp18);
3293 {
3294#line 148
3295 while (1) {
3296 while_continue: ;
3297 {
3298#line 148
3299 while (1) {
3300 while_continue___0: ;
3301 {
3302#line 148
3303 __cil_tmp19 = (unsigned long )pdata;
3304#line 148
3305 __cil_tmp20 = __cil_tmp19 + 48;
3306#line 148
3307 __cil_tmp21 = (spinlock_t *)__cil_tmp20;
3308#line 148
3309 tmp = spinlock_check(__cil_tmp21);
3310#line 148
3311 irqflags = _raw_spin_lock_irqsave(tmp);
3312 }
3313#line 148
3314 goto while_break___0;
3315 }
3316 while_break___0: ;
3317 }
3318#line 148
3319 goto while_break;
3320 }
3321 while_break: ;
3322 }
3323 {
3324#line 150
3325 __cil_tmp22 = ioaddr + 131056;
3326#line 150
3327 __cil_tmp23 = (void const volatile *)__cil_tmp22;
3328#line 150
3329 flags = readb(__cil_tmp23);
3330#line 151
3331 __cil_tmp24 = (int )flags;
3332#line 151
3333 __cil_tmp25 = __cil_tmp24 | 2;
3334#line 151
3335 __cil_tmp26 = (unsigned char )__cil_tmp25;
3336#line 151
3337 __cil_tmp27 = ioaddr + 131056;
3338#line 151
3339 __cil_tmp28 = (void volatile *)__cil_tmp27;
3340#line 151
3341 writeb(__cil_tmp26, __cil_tmp28);
3342 }
3343 {
3344#line 153
3345 __cil_tmp29 = (unsigned long )pdata;
3346#line 153
3347 __cil_tmp30 = __cil_tmp29 + 44;
3348#line 153
3349 __cil_tmp31 = *((int *)__cil_tmp30);
3350#line 153
3351 if (__cil_tmp31 < 0) {
3352#line 153
3353 tmp___1 = 128;
3354 } else {
3355 {
3356#line 153
3357 __cil_tmp32 = (unsigned long )pdata;
3358#line 153
3359 __cil_tmp33 = __cil_tmp32 + 28;
3360#line 153
3361 __cil_tmp34 = *((unsigned int *)__cil_tmp33);
3362#line 153
3363 if (__cil_tmp34 & 16U) {
3364#line 153
3365 tmp___1 = 128;
3366 } else {
3367 {
3368#line 153
3369 __cil_tmp35 = (unsigned long )pdata;
3370#line 153
3371 __cil_tmp36 = __cil_tmp35 + 44;
3372#line 153
3373 __cil_tmp37 = *((int *)__cil_tmp36);
3374#line 153
3375 __cil_tmp38 = (unsigned int )__cil_tmp37;
3376#line 153
3377 tmp___0 = bin2bcd(__cil_tmp38);
3378#line 153
3379 tmp___1 = (int )tmp___0;
3380 }
3381 }
3382 }
3383 }
3384 }
3385 {
3386#line 153
3387 __cil_tmp39 = (unsigned char )tmp___1;
3388#line 153
3389 __cil_tmp40 = ioaddr + 131061;
3390#line 153
3391 __cil_tmp41 = (void volatile *)__cil_tmp40;
3392#line 153
3393 writeb(__cil_tmp39, __cil_tmp41);
3394 }
3395 {
3396#line 156
3397 __cil_tmp42 = (unsigned long )pdata;
3398#line 156
3399 __cil_tmp43 = __cil_tmp42 + 40;
3400#line 156
3401 __cil_tmp44 = *((int *)__cil_tmp43);
3402#line 156
3403 if (__cil_tmp44 < 0) {
3404#line 156
3405 tmp___3 = 128;
3406 } else {
3407 {
3408#line 156
3409 __cil_tmp45 = (unsigned long )pdata;
3410#line 156
3411 __cil_tmp46 = __cil_tmp45 + 28;
3412#line 156
3413 __cil_tmp47 = *((unsigned int *)__cil_tmp46);
3414#line 156
3415 if (__cil_tmp47 & 16U) {
3416#line 156
3417 tmp___3 = 128;
3418 } else {
3419 {
3420#line 156
3421 __cil_tmp48 = (unsigned long )pdata;
3422#line 156
3423 __cil_tmp49 = __cil_tmp48 + 40;
3424#line 156
3425 __cil_tmp50 = *((int *)__cil_tmp49);
3426#line 156
3427 __cil_tmp51 = (unsigned int )__cil_tmp50;
3428#line 156
3429 tmp___2 = bin2bcd(__cil_tmp51);
3430#line 156
3431 tmp___3 = (int )tmp___2;
3432 }
3433 }
3434 }
3435 }
3436 }
3437 {
3438#line 156
3439 __cil_tmp52 = (unsigned char )tmp___3;
3440#line 156
3441 __cil_tmp53 = ioaddr + 131060;
3442#line 156
3443 __cil_tmp54 = (void volatile *)__cil_tmp53;
3444#line 156
3445 writeb(__cil_tmp52, __cil_tmp54);
3446 }
3447 {
3448#line 159
3449 __cil_tmp55 = (unsigned long )pdata;
3450#line 159
3451 __cil_tmp56 = __cil_tmp55 + 36;
3452#line 159
3453 __cil_tmp57 = *((int *)__cil_tmp56);
3454#line 159
3455 if (__cil_tmp57 < 0) {
3456#line 159
3457 tmp___5 = 128;
3458 } else {
3459 {
3460#line 159
3461 __cil_tmp58 = (unsigned long )pdata;
3462#line 159
3463 __cil_tmp59 = __cil_tmp58 + 28;
3464#line 159
3465 __cil_tmp60 = *((unsigned int *)__cil_tmp59);
3466#line 159
3467 if (__cil_tmp60 & 16U) {
3468#line 159
3469 tmp___5 = 128;
3470 } else {
3471 {
3472#line 159
3473 __cil_tmp61 = (unsigned long )pdata;
3474#line 159
3475 __cil_tmp62 = __cil_tmp61 + 36;
3476#line 159
3477 __cil_tmp63 = *((int *)__cil_tmp62);
3478#line 159
3479 __cil_tmp64 = (unsigned int )__cil_tmp63;
3480#line 159
3481 tmp___4 = bin2bcd(__cil_tmp64);
3482#line 159
3483 tmp___5 = (int )tmp___4;
3484 }
3485 }
3486 }
3487 }
3488 }
3489 {
3490#line 159
3491 __cil_tmp65 = (unsigned char )tmp___5;
3492#line 159
3493 __cil_tmp66 = ioaddr + 131059;
3494#line 159
3495 __cil_tmp67 = (void volatile *)__cil_tmp66;
3496#line 159
3497 writeb(__cil_tmp65, __cil_tmp67);
3498 }
3499 {
3500#line 162
3501 __cil_tmp68 = (unsigned long )pdata;
3502#line 162
3503 __cil_tmp69 = __cil_tmp68 + 32;
3504#line 162
3505 __cil_tmp70 = *((int *)__cil_tmp69);
3506#line 162
3507 if (__cil_tmp70 < 0) {
3508#line 162
3509 tmp___7 = 128;
3510 } else {
3511 {
3512#line 162
3513 __cil_tmp71 = (unsigned long )pdata;
3514#line 162
3515 __cil_tmp72 = __cil_tmp71 + 28;
3516#line 162
3517 __cil_tmp73 = *((unsigned int *)__cil_tmp72);
3518#line 162
3519 if (__cil_tmp73 & 16U) {
3520#line 162
3521 tmp___7 = 128;
3522 } else {
3523 {
3524#line 162
3525 __cil_tmp74 = (unsigned long )pdata;
3526#line 162
3527 __cil_tmp75 = __cil_tmp74 + 32;
3528#line 162
3529 __cil_tmp76 = *((int *)__cil_tmp75);
3530#line 162
3531 __cil_tmp77 = (unsigned int )__cil_tmp76;
3532#line 162
3533 tmp___6 = bin2bcd(__cil_tmp77);
3534#line 162
3535 tmp___7 = (int )tmp___6;
3536 }
3537 }
3538 }
3539 }
3540 }
3541 {
3542#line 162
3543 __cil_tmp78 = (unsigned char )tmp___7;
3544#line 162
3545 __cil_tmp79 = ioaddr + 131058;
3546#line 162
3547 __cil_tmp80 = (void volatile *)__cil_tmp79;
3548#line 162
3549 writeb(__cil_tmp78, __cil_tmp80);
3550 }
3551 {
3552#line 165
3553 __cil_tmp81 = (unsigned long )pdata;
3554#line 165
3555 __cil_tmp82 = __cil_tmp81 + 28;
3556#line 165
3557 if (*((unsigned int *)__cil_tmp82)) {
3558#line 165
3559 tmp___8 = 64;
3560 } else {
3561#line 165
3562 tmp___8 = 0;
3563 }
3564 }
3565 {
3566#line 165
3567 __cil_tmp83 = (unsigned char )tmp___8;
3568#line 165
3569 __cil_tmp84 = ioaddr + 131062;
3570#line 165
3571 __cil_tmp85 = (void volatile *)__cil_tmp84;
3572#line 165
3573 writeb(__cil_tmp83, __cil_tmp85);
3574#line 166
3575 __cil_tmp86 = ioaddr + 131056;
3576#line 166
3577 __cil_tmp87 = (void const volatile *)__cil_tmp86;
3578#line 166
3579 readb(__cil_tmp87);
3580#line 167
3581 __cil_tmp88 = (int )flags;
3582#line 167
3583 __cil_tmp89 = __cil_tmp88 & -3;
3584#line 167
3585 __cil_tmp90 = (unsigned char )__cil_tmp89;
3586#line 167
3587 __cil_tmp91 = ioaddr + 131056;
3588#line 167
3589 __cil_tmp92 = (void volatile *)__cil_tmp91;
3590#line 167
3591 writeb(__cil_tmp90, __cil_tmp92);
3592#line 168
3593 __cil_tmp93 = (unsigned long )pdata;
3594#line 168
3595 __cil_tmp94 = __cil_tmp93 + 48;
3596#line 168
3597 __cil_tmp95 = (spinlock_t *)__cil_tmp94;
3598#line 168
3599 spin_unlock_irqrestore(__cil_tmp95, irqflags);
3600 }
3601#line 169
3602 return;
3603}
3604}
3605#line 171 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
3606static int stk17ta8_rtc_set_alarm(struct device *dev , struct rtc_wkalrm *alrm )
3607{ struct platform_device *pdev ;
3608 struct device const *__mptr ;
3609 struct rtc_plat_data *pdata ;
3610 void *tmp ;
3611 struct platform_device *__cil_tmp7 ;
3612 unsigned long __cil_tmp8 ;
3613 unsigned long __cil_tmp9 ;
3614 struct device *__cil_tmp10 ;
3615 unsigned int __cil_tmp11 ;
3616 char *__cil_tmp12 ;
3617 char *__cil_tmp13 ;
3618 struct platform_device const *__cil_tmp14 ;
3619 unsigned long __cil_tmp15 ;
3620 unsigned long __cil_tmp16 ;
3621 int __cil_tmp17 ;
3622 unsigned long __cil_tmp18 ;
3623 unsigned long __cil_tmp19 ;
3624 unsigned long __cil_tmp20 ;
3625 unsigned long __cil_tmp21 ;
3626 unsigned long __cil_tmp22 ;
3627 unsigned long __cil_tmp23 ;
3628 unsigned long __cil_tmp24 ;
3629 unsigned long __cil_tmp25 ;
3630 unsigned long __cil_tmp26 ;
3631 unsigned long __cil_tmp27 ;
3632 unsigned long __cil_tmp28 ;
3633 unsigned long __cil_tmp29 ;
3634 unsigned long __cil_tmp30 ;
3635 unsigned long __cil_tmp31 ;
3636 unsigned long __cil_tmp32 ;
3637 unsigned long __cil_tmp33 ;
3638 unsigned long __cil_tmp34 ;
3639 unsigned long __cil_tmp35 ;
3640 unsigned long __cil_tmp36 ;
3641 unsigned long __cil_tmp37 ;
3642 unsigned long __cil_tmp38 ;
3643 unsigned long __cil_tmp39 ;
3644 unsigned long __cil_tmp40 ;
3645 unsigned int __cil_tmp41 ;
3646
3647 {
3648 {
3649#line 173
3650 __mptr = (struct device const *)dev;
3651#line 173
3652 __cil_tmp7 = (struct platform_device *)0;
3653#line 173
3654 __cil_tmp8 = (unsigned long )__cil_tmp7;
3655#line 173
3656 __cil_tmp9 = __cil_tmp8 + 16;
3657#line 173
3658 __cil_tmp10 = (struct device *)__cil_tmp9;
3659#line 173
3660 __cil_tmp11 = (unsigned int )__cil_tmp10;
3661#line 173
3662 __cil_tmp12 = (char *)__mptr;
3663#line 173
3664 __cil_tmp13 = __cil_tmp12 - __cil_tmp11;
3665#line 173
3666 pdev = (struct platform_device *)__cil_tmp13;
3667#line 174
3668 __cil_tmp14 = (struct platform_device const *)pdev;
3669#line 174
3670 tmp = platform_get_drvdata(__cil_tmp14);
3671#line 174
3672 pdata = (struct rtc_plat_data *)tmp;
3673 }
3674 {
3675#line 176
3676 __cil_tmp15 = (unsigned long )pdata;
3677#line 176
3678 __cil_tmp16 = __cil_tmp15 + 24;
3679#line 176
3680 __cil_tmp17 = *((int *)__cil_tmp16);
3681#line 176
3682 if (__cil_tmp17 <= 0) {
3683#line 177
3684 return (-22);
3685 } else {
3686
3687 }
3688 }
3689#line 178
3690 __cil_tmp18 = (unsigned long )pdata;
3691#line 178
3692 __cil_tmp19 = __cil_tmp18 + 44;
3693#line 178
3694 __cil_tmp20 = 4 + 12;
3695#line 178
3696 __cil_tmp21 = (unsigned long )alrm;
3697#line 178
3698 __cil_tmp22 = __cil_tmp21 + __cil_tmp20;
3699#line 178
3700 *((int *)__cil_tmp19) = *((int *)__cil_tmp22);
3701#line 179
3702 __cil_tmp23 = (unsigned long )pdata;
3703#line 179
3704 __cil_tmp24 = __cil_tmp23 + 40;
3705#line 179
3706 __cil_tmp25 = 4 + 8;
3707#line 179
3708 __cil_tmp26 = (unsigned long )alrm;
3709#line 179
3710 __cil_tmp27 = __cil_tmp26 + __cil_tmp25;
3711#line 179
3712 *((int *)__cil_tmp24) = *((int *)__cil_tmp27);
3713#line 180
3714 __cil_tmp28 = (unsigned long )pdata;
3715#line 180
3716 __cil_tmp29 = __cil_tmp28 + 36;
3717#line 180
3718 __cil_tmp30 = 4 + 4;
3719#line 180
3720 __cil_tmp31 = (unsigned long )alrm;
3721#line 180
3722 __cil_tmp32 = __cil_tmp31 + __cil_tmp30;
3723#line 180
3724 *((int *)__cil_tmp29) = *((int *)__cil_tmp32);
3725#line 181
3726 __cil_tmp33 = (unsigned long )pdata;
3727#line 181
3728 __cil_tmp34 = __cil_tmp33 + 32;
3729#line 181
3730 __cil_tmp35 = (unsigned long )alrm;
3731#line 181
3732 __cil_tmp36 = __cil_tmp35 + 4;
3733#line 181
3734 *((int *)__cil_tmp34) = *((int *)__cil_tmp36);
3735#line 182
3736 if (*((unsigned char *)alrm)) {
3737#line 183
3738 __cil_tmp37 = (unsigned long )pdata;
3739#line 183
3740 __cil_tmp38 = __cil_tmp37 + 28;
3741#line 183
3742 __cil_tmp39 = (unsigned long )pdata;
3743#line 183
3744 __cil_tmp40 = __cil_tmp39 + 28;
3745#line 183
3746 __cil_tmp41 = *((unsigned int *)__cil_tmp40);
3747#line 183
3748 *((unsigned int *)__cil_tmp38) = __cil_tmp41 | 32U;
3749 } else {
3750
3751 }
3752 {
3753#line 184
3754 stk17ta8_rtc_update_alarm(pdata);
3755 }
3756#line 185
3757 return (0);
3758}
3759}
3760#line 188 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
3761static int stk17ta8_rtc_read_alarm(struct device *dev , struct rtc_wkalrm *alrm )
3762{ struct platform_device *pdev ;
3763 struct device const *__mptr ;
3764 struct rtc_plat_data *pdata ;
3765 void *tmp ;
3766 struct platform_device *__cil_tmp7 ;
3767 unsigned long __cil_tmp8 ;
3768 unsigned long __cil_tmp9 ;
3769 struct device *__cil_tmp10 ;
3770 unsigned int __cil_tmp11 ;
3771 char *__cil_tmp12 ;
3772 char *__cil_tmp13 ;
3773 struct platform_device const *__cil_tmp14 ;
3774 unsigned long __cil_tmp15 ;
3775 unsigned long __cil_tmp16 ;
3776 int __cil_tmp17 ;
3777 unsigned long __cil_tmp18 ;
3778 unsigned long __cil_tmp19 ;
3779 int __cil_tmp20 ;
3780 unsigned long __cil_tmp21 ;
3781 unsigned long __cil_tmp22 ;
3782 unsigned long __cil_tmp23 ;
3783 unsigned long __cil_tmp24 ;
3784 unsigned long __cil_tmp25 ;
3785 unsigned long __cil_tmp26 ;
3786 unsigned long __cil_tmp27 ;
3787 unsigned long __cil_tmp28 ;
3788 unsigned long __cil_tmp29 ;
3789 unsigned long __cil_tmp30 ;
3790 int __cil_tmp31 ;
3791 unsigned long __cil_tmp32 ;
3792 unsigned long __cil_tmp33 ;
3793 unsigned long __cil_tmp34 ;
3794 unsigned long __cil_tmp35 ;
3795 unsigned long __cil_tmp36 ;
3796 unsigned long __cil_tmp37 ;
3797 unsigned long __cil_tmp38 ;
3798 unsigned long __cil_tmp39 ;
3799 unsigned long __cil_tmp40 ;
3800 unsigned long __cil_tmp41 ;
3801 int __cil_tmp42 ;
3802 unsigned long __cil_tmp43 ;
3803 unsigned long __cil_tmp44 ;
3804 unsigned long __cil_tmp45 ;
3805 unsigned long __cil_tmp46 ;
3806 unsigned long __cil_tmp47 ;
3807 unsigned long __cil_tmp48 ;
3808 unsigned long __cil_tmp49 ;
3809 unsigned long __cil_tmp50 ;
3810 unsigned long __cil_tmp51 ;
3811 unsigned long __cil_tmp52 ;
3812 int __cil_tmp53 ;
3813 unsigned long __cil_tmp54 ;
3814 unsigned long __cil_tmp55 ;
3815 unsigned long __cil_tmp56 ;
3816 unsigned long __cil_tmp57 ;
3817 unsigned long __cil_tmp58 ;
3818 unsigned long __cil_tmp59 ;
3819 unsigned long __cil_tmp60 ;
3820 unsigned long __cil_tmp61 ;
3821 unsigned int __cil_tmp62 ;
3822
3823 {
3824 {
3825#line 190
3826 __mptr = (struct device const *)dev;
3827#line 190
3828 __cil_tmp7 = (struct platform_device *)0;
3829#line 190
3830 __cil_tmp8 = (unsigned long )__cil_tmp7;
3831#line 190
3832 __cil_tmp9 = __cil_tmp8 + 16;
3833#line 190
3834 __cil_tmp10 = (struct device *)__cil_tmp9;
3835#line 190
3836 __cil_tmp11 = (unsigned int )__cil_tmp10;
3837#line 190
3838 __cil_tmp12 = (char *)__mptr;
3839#line 190
3840 __cil_tmp13 = __cil_tmp12 - __cil_tmp11;
3841#line 190
3842 pdev = (struct platform_device *)__cil_tmp13;
3843#line 191
3844 __cil_tmp14 = (struct platform_device const *)pdev;
3845#line 191
3846 tmp = platform_get_drvdata(__cil_tmp14);
3847#line 191
3848 pdata = (struct rtc_plat_data *)tmp;
3849 }
3850 {
3851#line 193
3852 __cil_tmp15 = (unsigned long )pdata;
3853#line 193
3854 __cil_tmp16 = __cil_tmp15 + 24;
3855#line 193
3856 __cil_tmp17 = *((int *)__cil_tmp16);
3857#line 193
3858 if (__cil_tmp17 <= 0) {
3859#line 194
3860 return (-22);
3861 } else {
3862
3863 }
3864 }
3865 {
3866#line 195
3867 __cil_tmp18 = (unsigned long )pdata;
3868#line 195
3869 __cil_tmp19 = __cil_tmp18 + 44;
3870#line 195
3871 __cil_tmp20 = *((int *)__cil_tmp19);
3872#line 195
3873 if (__cil_tmp20 < 0) {
3874#line 195
3875 __cil_tmp21 = 4 + 12;
3876#line 195
3877 __cil_tmp22 = (unsigned long )alrm;
3878#line 195
3879 __cil_tmp23 = __cil_tmp22 + __cil_tmp21;
3880#line 195
3881 *((int *)__cil_tmp23) = 0;
3882 } else {
3883#line 195
3884 __cil_tmp24 = 4 + 12;
3885#line 195
3886 __cil_tmp25 = (unsigned long )alrm;
3887#line 195
3888 __cil_tmp26 = __cil_tmp25 + __cil_tmp24;
3889#line 195
3890 __cil_tmp27 = (unsigned long )pdata;
3891#line 195
3892 __cil_tmp28 = __cil_tmp27 + 44;
3893#line 195
3894 *((int *)__cil_tmp26) = *((int *)__cil_tmp28);
3895 }
3896 }
3897 {
3898#line 196
3899 __cil_tmp29 = (unsigned long )pdata;
3900#line 196
3901 __cil_tmp30 = __cil_tmp29 + 40;
3902#line 196
3903 __cil_tmp31 = *((int *)__cil_tmp30);
3904#line 196
3905 if (__cil_tmp31 < 0) {
3906#line 196
3907 __cil_tmp32 = 4 + 8;
3908#line 196
3909 __cil_tmp33 = (unsigned long )alrm;
3910#line 196
3911 __cil_tmp34 = __cil_tmp33 + __cil_tmp32;
3912#line 196
3913 *((int *)__cil_tmp34) = 0;
3914 } else {
3915#line 196
3916 __cil_tmp35 = 4 + 8;
3917#line 196
3918 __cil_tmp36 = (unsigned long )alrm;
3919#line 196
3920 __cil_tmp37 = __cil_tmp36 + __cil_tmp35;
3921#line 196
3922 __cil_tmp38 = (unsigned long )pdata;
3923#line 196
3924 __cil_tmp39 = __cil_tmp38 + 40;
3925#line 196
3926 *((int *)__cil_tmp37) = *((int *)__cil_tmp39);
3927 }
3928 }
3929 {
3930#line 197
3931 __cil_tmp40 = (unsigned long )pdata;
3932#line 197
3933 __cil_tmp41 = __cil_tmp40 + 36;
3934#line 197
3935 __cil_tmp42 = *((int *)__cil_tmp41);
3936#line 197
3937 if (__cil_tmp42 < 0) {
3938#line 197
3939 __cil_tmp43 = 4 + 4;
3940#line 197
3941 __cil_tmp44 = (unsigned long )alrm;
3942#line 197
3943 __cil_tmp45 = __cil_tmp44 + __cil_tmp43;
3944#line 197
3945 *((int *)__cil_tmp45) = 0;
3946 } else {
3947#line 197
3948 __cil_tmp46 = 4 + 4;
3949#line 197
3950 __cil_tmp47 = (unsigned long )alrm;
3951#line 197
3952 __cil_tmp48 = __cil_tmp47 + __cil_tmp46;
3953#line 197
3954 __cil_tmp49 = (unsigned long )pdata;
3955#line 197
3956 __cil_tmp50 = __cil_tmp49 + 36;
3957#line 197
3958 *((int *)__cil_tmp48) = *((int *)__cil_tmp50);
3959 }
3960 }
3961 {
3962#line 198
3963 __cil_tmp51 = (unsigned long )pdata;
3964#line 198
3965 __cil_tmp52 = __cil_tmp51 + 32;
3966#line 198
3967 __cil_tmp53 = *((int *)__cil_tmp52);
3968#line 198
3969 if (__cil_tmp53 < 0) {
3970#line 198
3971 __cil_tmp54 = (unsigned long )alrm;
3972#line 198
3973 __cil_tmp55 = __cil_tmp54 + 4;
3974#line 198
3975 *((int *)__cil_tmp55) = 0;
3976 } else {
3977#line 198
3978 __cil_tmp56 = (unsigned long )alrm;
3979#line 198
3980 __cil_tmp57 = __cil_tmp56 + 4;
3981#line 198
3982 __cil_tmp58 = (unsigned long )pdata;
3983#line 198
3984 __cil_tmp59 = __cil_tmp58 + 32;
3985#line 198
3986 *((int *)__cil_tmp57) = *((int *)__cil_tmp59);
3987 }
3988 }
3989 {
3990#line 199
3991 __cil_tmp60 = (unsigned long )pdata;
3992#line 199
3993 __cil_tmp61 = __cil_tmp60 + 28;
3994#line 199
3995 __cil_tmp62 = *((unsigned int *)__cil_tmp61);
3996#line 199
3997 if (__cil_tmp62 & 32U) {
3998#line 199
3999 *((unsigned char *)alrm) = (unsigned char)1;
4000 } else {
4001#line 199
4002 *((unsigned char *)alrm) = (unsigned char)0;
4003 }
4004 }
4005#line 200
4006 return (0);
4007}
4008}
4009#line 203 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
4010static irqreturn_t stk17ta8_rtc_interrupt(int irq , void *dev_id )
4011{ struct platform_device *pdev ;
4012 struct rtc_plat_data *pdata ;
4013 void *tmp ;
4014 void *ioaddr ;
4015 unsigned long events ;
4016 unsigned char tmp___0 ;
4017 long tmp___1 ;
4018 unsigned char tmp___2 ;
4019 int tmp___3 ;
4020 struct platform_device const *__cil_tmp12 ;
4021 unsigned long __cil_tmp13 ;
4022 unsigned long __cil_tmp14 ;
4023 unsigned long __cil_tmp15 ;
4024 unsigned long __cil_tmp16 ;
4025 spinlock_t *__cil_tmp17 ;
4026 void *__cil_tmp18 ;
4027 void const volatile *__cil_tmp19 ;
4028 int __cil_tmp20 ;
4029 void *__cil_tmp21 ;
4030 void const volatile *__cil_tmp22 ;
4031 int __cil_tmp23 ;
4032 struct rtc_device *__cil_tmp24 ;
4033 int __cil_tmp25 ;
4034 int __cil_tmp26 ;
4035 long __cil_tmp27 ;
4036 struct rtc_device *__cil_tmp28 ;
4037 unsigned long __cil_tmp29 ;
4038 unsigned long __cil_tmp30 ;
4039 spinlock_t *__cil_tmp31 ;
4040
4041 {
4042 {
4043#line 205
4044 pdev = (struct platform_device *)dev_id;
4045#line 206
4046 __cil_tmp12 = (struct platform_device const *)pdev;
4047#line 206
4048 tmp = platform_get_drvdata(__cil_tmp12);
4049#line 206
4050 pdata = (struct rtc_plat_data *)tmp;
4051#line 207
4052 __cil_tmp13 = (unsigned long )pdata;
4053#line 207
4054 __cil_tmp14 = __cil_tmp13 + 8;
4055#line 207
4056 ioaddr = *((void **)__cil_tmp14);
4057#line 208
4058 events = 0UL;
4059#line 210
4060 __cil_tmp15 = (unsigned long )pdata;
4061#line 210
4062 __cil_tmp16 = __cil_tmp15 + 48;
4063#line 210
4064 __cil_tmp17 = (spinlock_t *)__cil_tmp16;
4065#line 210
4066 spin_lock(__cil_tmp17);
4067#line 212
4068 __cil_tmp18 = ioaddr + 131056;
4069#line 212
4070 __cil_tmp19 = (void const volatile *)__cil_tmp18;
4071#line 212
4072 tmp___2 = readb(__cil_tmp19);
4073 }
4074 {
4075#line 212
4076 __cil_tmp20 = (int )tmp___2;
4077#line 212
4078 if (__cil_tmp20 & 64) {
4079 {
4080#line 213
4081 events = 128UL;
4082#line 214
4083 __cil_tmp21 = ioaddr + 131058;
4084#line 214
4085 __cil_tmp22 = (void const volatile *)__cil_tmp21;
4086#line 214
4087 tmp___0 = readb(__cil_tmp22);
4088 }
4089 {
4090#line 214
4091 __cil_tmp23 = (int )tmp___0;
4092#line 214
4093 if (__cil_tmp23 & 128) {
4094#line 215
4095 events = events | 16UL;
4096 } else {
4097#line 217
4098 events = events | 32UL;
4099 }
4100 }
4101 {
4102#line 218
4103 __cil_tmp24 = *((struct rtc_device **)pdata);
4104#line 218
4105 __cil_tmp25 = ! __cil_tmp24;
4106#line 218
4107 __cil_tmp26 = ! __cil_tmp25;
4108#line 218
4109 __cil_tmp27 = (long )__cil_tmp26;
4110#line 218
4111 tmp___1 = __builtin_expect(__cil_tmp27, 1L);
4112 }
4113#line 218
4114 if (tmp___1) {
4115 {
4116#line 219
4117 __cil_tmp28 = *((struct rtc_device **)pdata);
4118#line 219
4119 rtc_update_irq(__cil_tmp28, 1UL, events);
4120 }
4121 } else {
4122
4123 }
4124 } else {
4125
4126 }
4127 }
4128 {
4129#line 221
4130 __cil_tmp29 = (unsigned long )pdata;
4131#line 221
4132 __cil_tmp30 = __cil_tmp29 + 48;
4133#line 221
4134 __cil_tmp31 = (spinlock_t *)__cil_tmp30;
4135#line 221
4136 spin_unlock(__cil_tmp31);
4137 }
4138#line 222
4139 if (events) {
4140#line 222
4141 tmp___3 = 1;
4142 } else {
4143#line 222
4144 tmp___3 = 0;
4145 }
4146#line 222
4147 return ((irqreturn_t )tmp___3);
4148}
4149}
4150#line 225 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
4151static int stk17ta8_rtc_alarm_irq_enable(struct device *dev , unsigned int enabled )
4152{ struct platform_device *pdev ;
4153 struct device const *__mptr ;
4154 struct rtc_plat_data *pdata ;
4155 void *tmp ;
4156 struct platform_device *__cil_tmp7 ;
4157 unsigned long __cil_tmp8 ;
4158 unsigned long __cil_tmp9 ;
4159 struct device *__cil_tmp10 ;
4160 unsigned int __cil_tmp11 ;
4161 char *__cil_tmp12 ;
4162 char *__cil_tmp13 ;
4163 struct platform_device const *__cil_tmp14 ;
4164 unsigned long __cil_tmp15 ;
4165 unsigned long __cil_tmp16 ;
4166 int __cil_tmp17 ;
4167 unsigned long __cil_tmp18 ;
4168 unsigned long __cil_tmp19 ;
4169 unsigned long __cil_tmp20 ;
4170 unsigned long __cil_tmp21 ;
4171 unsigned int __cil_tmp22 ;
4172 unsigned long __cil_tmp23 ;
4173 unsigned long __cil_tmp24 ;
4174 unsigned long __cil_tmp25 ;
4175 unsigned long __cil_tmp26 ;
4176 unsigned int __cil_tmp27 ;
4177
4178 {
4179 {
4180#line 228
4181 __mptr = (struct device const *)dev;
4182#line 228
4183 __cil_tmp7 = (struct platform_device *)0;
4184#line 228
4185 __cil_tmp8 = (unsigned long )__cil_tmp7;
4186#line 228
4187 __cil_tmp9 = __cil_tmp8 + 16;
4188#line 228
4189 __cil_tmp10 = (struct device *)__cil_tmp9;
4190#line 228
4191 __cil_tmp11 = (unsigned int )__cil_tmp10;
4192#line 228
4193 __cil_tmp12 = (char *)__mptr;
4194#line 228
4195 __cil_tmp13 = __cil_tmp12 - __cil_tmp11;
4196#line 228
4197 pdev = (struct platform_device *)__cil_tmp13;
4198#line 229
4199 __cil_tmp14 = (struct platform_device const *)pdev;
4200#line 229
4201 tmp = platform_get_drvdata(__cil_tmp14);
4202#line 229
4203 pdata = (struct rtc_plat_data *)tmp;
4204 }
4205 {
4206#line 231
4207 __cil_tmp15 = (unsigned long )pdata;
4208#line 231
4209 __cil_tmp16 = __cil_tmp15 + 24;
4210#line 231
4211 __cil_tmp17 = *((int *)__cil_tmp16);
4212#line 231
4213 if (__cil_tmp17 <= 0) {
4214#line 232
4215 return (-22);
4216 } else {
4217
4218 }
4219 }
4220#line 233
4221 if (enabled) {
4222#line 234
4223 __cil_tmp18 = (unsigned long )pdata;
4224#line 234
4225 __cil_tmp19 = __cil_tmp18 + 28;
4226#line 234
4227 __cil_tmp20 = (unsigned long )pdata;
4228#line 234
4229 __cil_tmp21 = __cil_tmp20 + 28;
4230#line 234
4231 __cil_tmp22 = *((unsigned int *)__cil_tmp21);
4232#line 234
4233 *((unsigned int *)__cil_tmp19) = __cil_tmp22 | 32U;
4234 } else {
4235#line 236
4236 __cil_tmp23 = (unsigned long )pdata;
4237#line 236
4238 __cil_tmp24 = __cil_tmp23 + 28;
4239#line 236
4240 __cil_tmp25 = (unsigned long )pdata;
4241#line 236
4242 __cil_tmp26 = __cil_tmp25 + 28;
4243#line 236
4244 __cil_tmp27 = *((unsigned int *)__cil_tmp26);
4245#line 236
4246 *((unsigned int *)__cil_tmp24) = __cil_tmp27 & 4294967263U;
4247 }
4248 {
4249#line 237
4250 stk17ta8_rtc_update_alarm(pdata);
4251 }
4252#line 238
4253 return (0);
4254}
4255}
4256#line 241 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
4257static struct rtc_class_ops const stk17ta8_rtc_ops =
4258#line 241
4259 {(int (*)(struct device * ))0, (void (*)(struct device * ))0, (int (*)(struct device * ,
4260 unsigned int ,
4261 unsigned long ))0,
4262 & stk17ta8_rtc_read_time, & stk17ta8_rtc_set_time, & stk17ta8_rtc_read_alarm,
4263 & stk17ta8_rtc_set_alarm, (int (*)(struct device * , struct seq_file * ))0, (int (*)(struct device * ,
4264 unsigned long secs ))0,
4265 (int (*)(struct device * , int data ))0, & stk17ta8_rtc_alarm_irq_enable};
4266#line 249 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
4267static ssize_t stk17ta8_nvram_read(struct file *filp , struct kobject *kobj , struct bin_attribute *attr ,
4268 char *buf , loff_t pos , size_t size )
4269{ struct device *dev ;
4270 struct kobject const *__mptr ;
4271 struct platform_device *pdev ;
4272 struct device const *__mptr___0 ;
4273 struct rtc_plat_data *pdata ;
4274 void *tmp ;
4275 void *ioaddr ;
4276 ssize_t count ;
4277 char *tmp___0 ;
4278 loff_t tmp___1 ;
4279 unsigned char tmp___2 ;
4280 struct device *__cil_tmp18 ;
4281 unsigned long __cil_tmp19 ;
4282 unsigned long __cil_tmp20 ;
4283 struct kobject *__cil_tmp21 ;
4284 unsigned int __cil_tmp22 ;
4285 char *__cil_tmp23 ;
4286 char *__cil_tmp24 ;
4287 struct platform_device *__cil_tmp25 ;
4288 unsigned long __cil_tmp26 ;
4289 unsigned long __cil_tmp27 ;
4290 struct device *__cil_tmp28 ;
4291 unsigned int __cil_tmp29 ;
4292 char *__cil_tmp30 ;
4293 char *__cil_tmp31 ;
4294 struct platform_device const *__cil_tmp32 ;
4295 unsigned long __cil_tmp33 ;
4296 unsigned long __cil_tmp34 ;
4297 void *__cil_tmp35 ;
4298 void const volatile *__cil_tmp36 ;
4299
4300 {
4301 {
4302#line 253
4303 __mptr = (struct kobject const *)kobj;
4304#line 253
4305 __cil_tmp18 = (struct device *)0;
4306#line 253
4307 __cil_tmp19 = (unsigned long )__cil_tmp18;
4308#line 253
4309 __cil_tmp20 = __cil_tmp19 + 16;
4310#line 253
4311 __cil_tmp21 = (struct kobject *)__cil_tmp20;
4312#line 253
4313 __cil_tmp22 = (unsigned int )__cil_tmp21;
4314#line 253
4315 __cil_tmp23 = (char *)__mptr;
4316#line 253
4317 __cil_tmp24 = __cil_tmp23 - __cil_tmp22;
4318#line 253
4319 dev = (struct device *)__cil_tmp24;
4320#line 254
4321 __mptr___0 = (struct device const *)dev;
4322#line 254
4323 __cil_tmp25 = (struct platform_device *)0;
4324#line 254
4325 __cil_tmp26 = (unsigned long )__cil_tmp25;
4326#line 254
4327 __cil_tmp27 = __cil_tmp26 + 16;
4328#line 254
4329 __cil_tmp28 = (struct device *)__cil_tmp27;
4330#line 254
4331 __cil_tmp29 = (unsigned int )__cil_tmp28;
4332#line 254
4333 __cil_tmp30 = (char *)__mptr___0;
4334#line 254
4335 __cil_tmp31 = __cil_tmp30 - __cil_tmp29;
4336#line 254
4337 pdev = (struct platform_device *)__cil_tmp31;
4338#line 255
4339 __cil_tmp32 = (struct platform_device const *)pdev;
4340#line 255
4341 tmp = platform_get_drvdata(__cil_tmp32);
4342#line 255
4343 pdata = (struct rtc_plat_data *)tmp;
4344#line 256
4345 __cil_tmp33 = (unsigned long )pdata;
4346#line 256
4347 __cil_tmp34 = __cil_tmp33 + 8;
4348#line 256
4349 ioaddr = *((void **)__cil_tmp34);
4350#line 259
4351 count = (ssize_t )0;
4352 }
4353 {
4354#line 259
4355 while (1) {
4356 while_continue: ;
4357#line 259
4358 if (size > 0UL) {
4359#line 259
4360 if (pos < 131056LL) {
4361
4362 } else {
4363#line 259
4364 goto while_break;
4365 }
4366 } else {
4367#line 259
4368 goto while_break;
4369 }
4370 {
4371#line 260
4372 tmp___0 = buf;
4373#line 260
4374 buf = buf + 1;
4375#line 260
4376 tmp___1 = pos;
4377#line 260
4378 pos = pos + 1LL;
4379#line 260
4380 __cil_tmp35 = ioaddr + tmp___1;
4381#line 260
4382 __cil_tmp36 = (void const volatile *)__cil_tmp35;
4383#line 260
4384 tmp___2 = readb(__cil_tmp36);
4385#line 260
4386 *tmp___0 = (char )tmp___2;
4387#line 259
4388 count = count + 1L;
4389#line 259
4390 size = size - 1UL;
4391 }
4392 }
4393 while_break: ;
4394 }
4395#line 261
4396 return (count);
4397}
4398}
4399#line 264 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
4400static ssize_t stk17ta8_nvram_write(struct file *filp , struct kobject *kobj , struct bin_attribute *attr ,
4401 char *buf , loff_t pos , size_t size )
4402{ struct device *dev ;
4403 struct kobject const *__mptr ;
4404 struct platform_device *pdev ;
4405 struct device const *__mptr___0 ;
4406 struct rtc_plat_data *pdata ;
4407 void *tmp ;
4408 void *ioaddr ;
4409 ssize_t count ;
4410 loff_t tmp___0 ;
4411 char *tmp___1 ;
4412 struct device *__cil_tmp17 ;
4413 unsigned long __cil_tmp18 ;
4414 unsigned long __cil_tmp19 ;
4415 struct kobject *__cil_tmp20 ;
4416 unsigned int __cil_tmp21 ;
4417 char *__cil_tmp22 ;
4418 char *__cil_tmp23 ;
4419 struct platform_device *__cil_tmp24 ;
4420 unsigned long __cil_tmp25 ;
4421 unsigned long __cil_tmp26 ;
4422 struct device *__cil_tmp27 ;
4423 unsigned int __cil_tmp28 ;
4424 char *__cil_tmp29 ;
4425 char *__cil_tmp30 ;
4426 struct platform_device const *__cil_tmp31 ;
4427 unsigned long __cil_tmp32 ;
4428 unsigned long __cil_tmp33 ;
4429 char __cil_tmp34 ;
4430 unsigned char __cil_tmp35 ;
4431 void *__cil_tmp36 ;
4432 void volatile *__cil_tmp37 ;
4433
4434 {
4435 {
4436#line 268
4437 __mptr = (struct kobject const *)kobj;
4438#line 268
4439 __cil_tmp17 = (struct device *)0;
4440#line 268
4441 __cil_tmp18 = (unsigned long )__cil_tmp17;
4442#line 268
4443 __cil_tmp19 = __cil_tmp18 + 16;
4444#line 268
4445 __cil_tmp20 = (struct kobject *)__cil_tmp19;
4446#line 268
4447 __cil_tmp21 = (unsigned int )__cil_tmp20;
4448#line 268
4449 __cil_tmp22 = (char *)__mptr;
4450#line 268
4451 __cil_tmp23 = __cil_tmp22 - __cil_tmp21;
4452#line 268
4453 dev = (struct device *)__cil_tmp23;
4454#line 269
4455 __mptr___0 = (struct device const *)dev;
4456#line 269
4457 __cil_tmp24 = (struct platform_device *)0;
4458#line 269
4459 __cil_tmp25 = (unsigned long )__cil_tmp24;
4460#line 269
4461 __cil_tmp26 = __cil_tmp25 + 16;
4462#line 269
4463 __cil_tmp27 = (struct device *)__cil_tmp26;
4464#line 269
4465 __cil_tmp28 = (unsigned int )__cil_tmp27;
4466#line 269
4467 __cil_tmp29 = (char *)__mptr___0;
4468#line 269
4469 __cil_tmp30 = __cil_tmp29 - __cil_tmp28;
4470#line 269
4471 pdev = (struct platform_device *)__cil_tmp30;
4472#line 270
4473 __cil_tmp31 = (struct platform_device const *)pdev;
4474#line 270
4475 tmp = platform_get_drvdata(__cil_tmp31);
4476#line 270
4477 pdata = (struct rtc_plat_data *)tmp;
4478#line 271
4479 __cil_tmp32 = (unsigned long )pdata;
4480#line 271
4481 __cil_tmp33 = __cil_tmp32 + 8;
4482#line 271
4483 ioaddr = *((void **)__cil_tmp33);
4484#line 274
4485 count = (ssize_t )0;
4486 }
4487 {
4488#line 274
4489 while (1) {
4490 while_continue: ;
4491#line 274
4492 if (size > 0UL) {
4493#line 274
4494 if (pos < 131056LL) {
4495
4496 } else {
4497#line 274
4498 goto while_break;
4499 }
4500 } else {
4501#line 274
4502 goto while_break;
4503 }
4504 {
4505#line 275
4506 tmp___0 = pos;
4507#line 275
4508 pos = pos + 1LL;
4509#line 275
4510 tmp___1 = buf;
4511#line 275
4512 buf = buf + 1;
4513#line 275
4514 __cil_tmp34 = *tmp___1;
4515#line 275
4516 __cil_tmp35 = (unsigned char )__cil_tmp34;
4517#line 275
4518 __cil_tmp36 = ioaddr + tmp___0;
4519#line 275
4520 __cil_tmp37 = (void volatile *)__cil_tmp36;
4521#line 275
4522 writeb(__cil_tmp35, __cil_tmp37);
4523#line 274
4524 count = count + 1L;
4525#line 274
4526 size = size - 1UL;
4527 }
4528 }
4529 while_break: ;
4530 }
4531#line 276
4532 return (count);
4533}
4534}
4535#line 279 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
4536static struct bin_attribute stk17ta8_nvram_attr = {{"nvram", (umode_t )420}, (size_t )131056, (void *)0, & stk17ta8_nvram_read, & stk17ta8_nvram_write,
4537 (int (*)(struct file * , struct kobject * , struct bin_attribute *attr , struct vm_area_struct *vma ))0};
4538#line 326 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
4539static struct lock_class_key __key___3 ;
4540#line 289
4541static int stk17ta8_rtc_probe(struct platform_device *pdev ) __attribute__((__section__(".devinit.text"),
4542__no_instrument_function__)) ;
4543#line 289 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
4544static int stk17ta8_rtc_probe(struct platform_device *pdev )
4545{ struct resource *res ;
4546 unsigned int cal ;
4547 unsigned int flags ;
4548 struct rtc_plat_data *pdata ;
4549 void *ioaddr ;
4550 int ret ;
4551 void *tmp ;
4552 struct resource *tmp___0 ;
4553 unsigned char tmp___1 ;
4554 unsigned char tmp___2 ;
4555 unsigned char tmp___3 ;
4556 int tmp___4 ;
4557 long tmp___5 ;
4558 long tmp___6 ;
4559 unsigned long __cil_tmp16 ;
4560 unsigned long __cil_tmp17 ;
4561 struct device *__cil_tmp18 ;
4562 unsigned long __cil_tmp19 ;
4563 unsigned long __cil_tmp20 ;
4564 struct device *__cil_tmp21 ;
4565 resource_size_t __cil_tmp22 ;
4566 resource_size_t __cil_tmp23 ;
4567 char const *__cil_tmp24 ;
4568 unsigned long __cil_tmp25 ;
4569 unsigned long __cil_tmp26 ;
4570 struct device *__cil_tmp27 ;
4571 resource_size_t __cil_tmp28 ;
4572 unsigned long __cil_tmp29 ;
4573 unsigned long __cil_tmp30 ;
4574 unsigned long __cil_tmp31 ;
4575 unsigned long __cil_tmp32 ;
4576 void *__cil_tmp33 ;
4577 void const volatile *__cil_tmp34 ;
4578 void *__cil_tmp35 ;
4579 void const volatile *__cil_tmp36 ;
4580 unsigned int __cil_tmp37 ;
4581 unsigned char __cil_tmp38 ;
4582 void *__cil_tmp39 ;
4583 void volatile *__cil_tmp40 ;
4584 unsigned char __cil_tmp41 ;
4585 void *__cil_tmp42 ;
4586 void volatile *__cil_tmp43 ;
4587 unsigned int __cil_tmp44 ;
4588 unsigned char __cil_tmp45 ;
4589 void *__cil_tmp46 ;
4590 void volatile *__cil_tmp47 ;
4591 void *__cil_tmp48 ;
4592 void const volatile *__cil_tmp49 ;
4593 int __cil_tmp50 ;
4594 unsigned long __cil_tmp51 ;
4595 unsigned long __cil_tmp52 ;
4596 struct device *__cil_tmp53 ;
4597 struct device const *__cil_tmp54 ;
4598 unsigned long __cil_tmp55 ;
4599 unsigned long __cil_tmp56 ;
4600 spinlock_t *__cil_tmp57 ;
4601 unsigned long __cil_tmp58 ;
4602 unsigned long __cil_tmp59 ;
4603 struct raw_spinlock *__cil_tmp60 ;
4604 unsigned long __cil_tmp61 ;
4605 unsigned long __cil_tmp62 ;
4606 void *__cil_tmp63 ;
4607 unsigned long __cil_tmp64 ;
4608 unsigned long __cil_tmp65 ;
4609 int __cil_tmp66 ;
4610 void *__cil_tmp67 ;
4611 void volatile *__cil_tmp68 ;
4612 unsigned long __cil_tmp69 ;
4613 unsigned long __cil_tmp70 ;
4614 struct device *__cil_tmp71 ;
4615 unsigned long __cil_tmp72 ;
4616 unsigned long __cil_tmp73 ;
4617 int __cil_tmp74 ;
4618 unsigned int __cil_tmp75 ;
4619 char const *__cil_tmp76 ;
4620 void *__cil_tmp77 ;
4621 unsigned long __cil_tmp78 ;
4622 unsigned long __cil_tmp79 ;
4623 struct device *__cil_tmp80 ;
4624 struct device const *__cil_tmp81 ;
4625 unsigned long __cil_tmp82 ;
4626 unsigned long __cil_tmp83 ;
4627 char const *__cil_tmp84 ;
4628 unsigned long __cil_tmp85 ;
4629 unsigned long __cil_tmp86 ;
4630 struct device *__cil_tmp87 ;
4631 struct rtc_device *__cil_tmp88 ;
4632 void const *__cil_tmp89 ;
4633 struct rtc_device *__cil_tmp90 ;
4634 void const *__cil_tmp91 ;
4635 unsigned long __cil_tmp92 ;
4636 unsigned long __cil_tmp93 ;
4637 unsigned long __cil_tmp94 ;
4638 struct kobject *__cil_tmp95 ;
4639 struct bin_attribute const *__cil_tmp96 ;
4640 struct rtc_device *__cil_tmp97 ;
4641
4642 {
4643 {
4644#line 296
4645 ret = 0;
4646#line 298
4647 res = platform_get_resource(pdev, 512U, 0U);
4648 }
4649#line 299
4650 if (! res) {
4651#line 300
4652 return (-19);
4653 } else {
4654
4655 }
4656 {
4657#line 302
4658 __cil_tmp16 = (unsigned long )pdev;
4659#line 302
4660 __cil_tmp17 = __cil_tmp16 + 16;
4661#line 302
4662 __cil_tmp18 = (struct device *)__cil_tmp17;
4663#line 302
4664 tmp = devm_kzalloc(__cil_tmp18, 72UL, 208U);
4665#line 302
4666 pdata = (struct rtc_plat_data *)tmp;
4667 }
4668#line 303
4669 if (! pdata) {
4670#line 304
4671 return (-12);
4672 } else {
4673
4674 }
4675 {
4676#line 305
4677 __cil_tmp19 = (unsigned long )pdev;
4678#line 305
4679 __cil_tmp20 = __cil_tmp19 + 16;
4680#line 305
4681 __cil_tmp21 = (struct device *)__cil_tmp20;
4682#line 305
4683 __cil_tmp22 = *((resource_size_t *)res);
4684#line 305
4685 __cil_tmp23 = (resource_size_t )131072;
4686#line 305
4687 __cil_tmp24 = *((char const **)pdev);
4688#line 305
4689 tmp___0 = __devm_request_region(__cil_tmp21, & iomem_resource, __cil_tmp22, __cil_tmp23,
4690 __cil_tmp24);
4691 }
4692#line 305
4693 if (tmp___0) {
4694
4695 } else {
4696#line 307
4697 return (-16);
4698 }
4699 {
4700#line 308
4701 __cil_tmp25 = (unsigned long )pdev;
4702#line 308
4703 __cil_tmp26 = __cil_tmp25 + 16;
4704#line 308
4705 __cil_tmp27 = (struct device *)__cil_tmp26;
4706#line 308
4707 __cil_tmp28 = *((resource_size_t *)res);
4708#line 308
4709 ioaddr = devm_ioremap(__cil_tmp27, __cil_tmp28, 131072UL);
4710 }
4711#line 309
4712 if (! ioaddr) {
4713#line 310
4714 return (-12);
4715 } else {
4716
4717 }
4718 {
4719#line 311
4720 __cil_tmp29 = (unsigned long )pdata;
4721#line 311
4722 __cil_tmp30 = __cil_tmp29 + 8;
4723#line 311
4724 *((void **)__cil_tmp30) = ioaddr;
4725#line 312
4726 __cil_tmp31 = (unsigned long )pdata;
4727#line 312
4728 __cil_tmp32 = __cil_tmp31 + 24;
4729#line 312
4730 *((int *)__cil_tmp32) = platform_get_irq(pdev, 0U);
4731#line 315
4732 __cil_tmp33 = ioaddr + 131064;
4733#line 315
4734 __cil_tmp34 = (void const volatile *)__cil_tmp33;
4735#line 315
4736 tmp___1 = readb(__cil_tmp34);
4737#line 315
4738 cal = (unsigned int )tmp___1;
4739 }
4740#line 316
4741 if (cal & 128U) {
4742 {
4743#line 317
4744 cal = cal & 63U;
4745#line 318
4746 __cil_tmp35 = ioaddr + 131056;
4747#line 318
4748 __cil_tmp36 = (void const volatile *)__cil_tmp35;
4749#line 318
4750 tmp___2 = readb(__cil_tmp36);
4751#line 318
4752 flags = (unsigned int )tmp___2;
4753#line 319
4754 __cil_tmp37 = flags | 2U;
4755#line 319
4756 __cil_tmp38 = (unsigned char )__cil_tmp37;
4757#line 319
4758 __cil_tmp39 = ioaddr + 131056;
4759#line 319
4760 __cil_tmp40 = (void volatile *)__cil_tmp39;
4761#line 319
4762 writeb(__cil_tmp38, __cil_tmp40);
4763#line 320
4764 __cil_tmp41 = (unsigned char )cal;
4765#line 320
4766 __cil_tmp42 = ioaddr + 131064;
4767#line 320
4768 __cil_tmp43 = (void volatile *)__cil_tmp42;
4769#line 320
4770 writeb(__cil_tmp41, __cil_tmp43);
4771#line 321
4772 __cil_tmp44 = flags & 4294967293U;
4773#line 321
4774 __cil_tmp45 = (unsigned char )__cil_tmp44;
4775#line 321
4776 __cil_tmp46 = ioaddr + 131056;
4777#line 321
4778 __cil_tmp47 = (void volatile *)__cil_tmp46;
4779#line 321
4780 writeb(__cil_tmp45, __cil_tmp47);
4781 }
4782 } else {
4783
4784 }
4785 {
4786#line 323
4787 __cil_tmp48 = ioaddr + 131056;
4788#line 323
4789 __cil_tmp49 = (void const volatile *)__cil_tmp48;
4790#line 323
4791 tmp___3 = readb(__cil_tmp49);
4792 }
4793 {
4794#line 323
4795 __cil_tmp50 = (int )tmp___3;
4796#line 323
4797 if (__cil_tmp50 & 32) {
4798 {
4799#line 324
4800 __cil_tmp51 = (unsigned long )pdev;
4801#line 324
4802 __cil_tmp52 = __cil_tmp51 + 16;
4803#line 324
4804 __cil_tmp53 = (struct device *)__cil_tmp52;
4805#line 324
4806 __cil_tmp54 = (struct device const *)__cil_tmp53;
4807#line 324
4808 dev_warn(__cil_tmp54, "voltage-low detected.\n");
4809 }
4810 } else {
4811
4812 }
4813 }
4814 {
4815#line 326
4816 while (1) {
4817 while_continue: ;
4818 {
4819#line 326
4820 __cil_tmp55 = (unsigned long )pdata;
4821#line 326
4822 __cil_tmp56 = __cil_tmp55 + 48;
4823#line 326
4824 __cil_tmp57 = (spinlock_t *)__cil_tmp56;
4825#line 326
4826 spinlock_check(__cil_tmp57);
4827 }
4828 {
4829#line 326
4830 while (1) {
4831 while_continue___0: ;
4832 {
4833#line 326
4834 __cil_tmp58 = (unsigned long )pdata;
4835#line 326
4836 __cil_tmp59 = __cil_tmp58 + 48;
4837#line 326
4838 __cil_tmp60 = (struct raw_spinlock *)__cil_tmp59;
4839#line 326
4840 __raw_spin_lock_init(__cil_tmp60, "&(&pdata->lock)->rlock", & __key___3);
4841 }
4842#line 326
4843 goto while_break___0;
4844 }
4845 while_break___0: ;
4846 }
4847#line 326
4848 goto while_break;
4849 }
4850 while_break: ;
4851 }
4852 {
4853#line 327
4854 __cil_tmp61 = (unsigned long )pdata;
4855#line 327
4856 __cil_tmp62 = __cil_tmp61 + 16;
4857#line 327
4858 *((unsigned long *)__cil_tmp62) = (unsigned long )jiffies;
4859#line 328
4860 __cil_tmp63 = (void *)pdata;
4861#line 328
4862 platform_set_drvdata(pdev, __cil_tmp63);
4863 }
4864 {
4865#line 329
4866 __cil_tmp64 = (unsigned long )pdata;
4867#line 329
4868 __cil_tmp65 = __cil_tmp64 + 24;
4869#line 329
4870 __cil_tmp66 = *((int *)__cil_tmp65);
4871#line 329
4872 if (__cil_tmp66 > 0) {
4873 {
4874#line 330
4875 __cil_tmp67 = ioaddr + 131062;
4876#line 330
4877 __cil_tmp68 = (void volatile *)__cil_tmp67;
4878#line 330
4879 writeb((unsigned char)0, __cil_tmp68);
4880#line 331
4881 __cil_tmp69 = (unsigned long )pdev;
4882#line 331
4883 __cil_tmp70 = __cil_tmp69 + 16;
4884#line 331
4885 __cil_tmp71 = (struct device *)__cil_tmp70;
4886#line 331
4887 __cil_tmp72 = (unsigned long )pdata;
4888#line 331
4889 __cil_tmp73 = __cil_tmp72 + 24;
4890#line 331
4891 __cil_tmp74 = *((int *)__cil_tmp73);
4892#line 331
4893 __cil_tmp75 = (unsigned int )__cil_tmp74;
4894#line 331
4895 __cil_tmp76 = *((char const **)pdev);
4896#line 331
4897 __cil_tmp77 = (void *)pdev;
4898#line 331
4899 tmp___4 = (int )devm_request_irq(__cil_tmp71, __cil_tmp75, & stk17ta8_rtc_interrupt,
4900 128UL, __cil_tmp76, __cil_tmp77);
4901 }
4902#line 331
4903 if (tmp___4 < 0) {
4904 {
4905#line 335
4906 __cil_tmp78 = (unsigned long )pdev;
4907#line 335
4908 __cil_tmp79 = __cil_tmp78 + 16;
4909#line 335
4910 __cil_tmp80 = (struct device *)__cil_tmp79;
4911#line 335
4912 __cil_tmp81 = (struct device const *)__cil_tmp80;
4913#line 335
4914 dev_warn(__cil_tmp81, "interrupt not available.\n");
4915#line 336
4916 __cil_tmp82 = (unsigned long )pdata;
4917#line 336
4918 __cil_tmp83 = __cil_tmp82 + 24;
4919#line 336
4920 *((int *)__cil_tmp83) = 0;
4921 }
4922 } else {
4923
4924 }
4925 } else {
4926
4927 }
4928 }
4929 {
4930#line 340
4931 __cil_tmp84 = *((char const **)pdev);
4932#line 340
4933 __cil_tmp85 = (unsigned long )pdev;
4934#line 340
4935 __cil_tmp86 = __cil_tmp85 + 16;
4936#line 340
4937 __cil_tmp87 = (struct device *)__cil_tmp86;
4938#line 340
4939 *((struct rtc_device **)pdata) = rtc_device_register(__cil_tmp84, __cil_tmp87, & stk17ta8_rtc_ops,
4940 & __this_module);
4941#line 342
4942 __cil_tmp88 = *((struct rtc_device **)pdata);
4943#line 342
4944 __cil_tmp89 = (void const *)__cil_tmp88;
4945#line 342
4946 tmp___6 = (long )IS_ERR(__cil_tmp89);
4947 }
4948#line 342
4949 if (tmp___6) {
4950 {
4951#line 343
4952 __cil_tmp90 = *((struct rtc_device **)pdata);
4953#line 343
4954 __cil_tmp91 = (void const *)__cil_tmp90;
4955#line 343
4956 tmp___5 = (long )PTR_ERR(__cil_tmp91);
4957 }
4958#line 343
4959 return ((int )tmp___5);
4960 } else {
4961
4962 }
4963 {
4964#line 345
4965 __cil_tmp92 = 16 + 16;
4966#line 345
4967 __cil_tmp93 = (unsigned long )pdev;
4968#line 345
4969 __cil_tmp94 = __cil_tmp93 + __cil_tmp92;
4970#line 345
4971 __cil_tmp95 = (struct kobject *)__cil_tmp94;
4972#line 345
4973 __cil_tmp96 = (struct bin_attribute const *)(& stk17ta8_nvram_attr);
4974#line 345
4975 ret = (int )sysfs_create_bin_file(__cil_tmp95, __cil_tmp96);
4976 }
4977#line 346
4978 if (ret) {
4979 {
4980#line 347
4981 __cil_tmp97 = *((struct rtc_device **)pdata);
4982#line 347
4983 rtc_device_unregister(__cil_tmp97);
4984 }
4985 } else {
4986
4987 }
4988#line 348
4989 return (ret);
4990}
4991}
4992#line 351
4993static int stk17ta8_rtc_remove(struct platform_device *pdev ) __attribute__((__section__(".devexit.text"),
4994__no_instrument_function__)) ;
4995#line 351 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
4996static int stk17ta8_rtc_remove(struct platform_device *pdev )
4997{ struct rtc_plat_data *pdata ;
4998 void *tmp ;
4999 struct platform_device const *__cil_tmp4 ;
5000 unsigned long __cil_tmp5 ;
5001 unsigned long __cil_tmp6 ;
5002 unsigned long __cil_tmp7 ;
5003 struct kobject *__cil_tmp8 ;
5004 struct bin_attribute const *__cil_tmp9 ;
5005 struct rtc_device *__cil_tmp10 ;
5006 unsigned long __cil_tmp11 ;
5007 unsigned long __cil_tmp12 ;
5008 int __cil_tmp13 ;
5009 unsigned long __cil_tmp14 ;
5010 unsigned long __cil_tmp15 ;
5011 void *__cil_tmp16 ;
5012 void *__cil_tmp17 ;
5013 void volatile *__cil_tmp18 ;
5014
5015 {
5016 {
5017#line 353
5018 __cil_tmp4 = (struct platform_device const *)pdev;
5019#line 353
5020 tmp = platform_get_drvdata(__cil_tmp4);
5021#line 353
5022 pdata = (struct rtc_plat_data *)tmp;
5023#line 355
5024 __cil_tmp5 = 16 + 16;
5025#line 355
5026 __cil_tmp6 = (unsigned long )pdev;
5027#line 355
5028 __cil_tmp7 = __cil_tmp6 + __cil_tmp5;
5029#line 355
5030 __cil_tmp8 = (struct kobject *)__cil_tmp7;
5031#line 355
5032 __cil_tmp9 = (struct bin_attribute const *)(& stk17ta8_nvram_attr);
5033#line 355
5034 sysfs_remove_bin_file(__cil_tmp8, __cil_tmp9);
5035#line 356
5036 __cil_tmp10 = *((struct rtc_device **)pdata);
5037#line 356
5038 rtc_device_unregister(__cil_tmp10);
5039 }
5040 {
5041#line 357
5042 __cil_tmp11 = (unsigned long )pdata;
5043#line 357
5044 __cil_tmp12 = __cil_tmp11 + 24;
5045#line 357
5046 __cil_tmp13 = *((int *)__cil_tmp12);
5047#line 357
5048 if (__cil_tmp13 > 0) {
5049 {
5050#line 358
5051 __cil_tmp14 = (unsigned long )pdata;
5052#line 358
5053 __cil_tmp15 = __cil_tmp14 + 8;
5054#line 358
5055 __cil_tmp16 = *((void **)__cil_tmp15);
5056#line 358
5057 __cil_tmp17 = __cil_tmp16 + 131062;
5058#line 358
5059 __cil_tmp18 = (void volatile *)__cil_tmp17;
5060#line 358
5061 writeb((unsigned char)0, __cil_tmp18);
5062 }
5063 } else {
5064
5065 }
5066 }
5067#line 359
5068 return (0);
5069}
5070}
5071#line 363 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5072static char const __mod_alias363[24] __attribute__((__used__, __unused__, __section__(".modinfo"),
5073__aligned__(1))) =
5074#line 363
5075 { (char const )'a', (char const )'l', (char const )'i', (char const )'a',
5076 (char const )'s', (char const )'=', (char const )'p', (char const )'l',
5077 (char const )'a', (char const )'t', (char const )'f', (char const )'o',
5078 (char const )'r', (char const )'m', (char const )':', (char const )'s',
5079 (char const )'t', (char const )'k', (char const )'1', (char const )'7',
5080 (char const )'t', (char const )'a', (char const )'8', (char const )'\000'};
5081#line 365 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5082static struct platform_driver stk17ta8_rtc_driver = {& stk17ta8_rtc_probe, & stk17ta8_rtc_remove, (void (*)(struct platform_device * ))0,
5083 (int (*)(struct platform_device * , pm_message_t state ))0, (int (*)(struct platform_device * ))0,
5084 {"stk17ta8", (struct bus_type *)0, & __this_module, (char const *)0, (_Bool)0,
5085 (struct of_device_id const *)0, (int (*)(struct device *dev ))0, (int (*)(struct device *dev ))0,
5086 (void (*)(struct device *dev ))0, (int (*)(struct device *dev , pm_message_t state ))0,
5087 (int (*)(struct device *dev ))0, (struct attribute_group const **)0, (struct dev_pm_ops const *)0,
5088 (struct driver_private *)0}, (struct platform_device_id const *)0};
5089#line 374
5090static int stk17ta8_rtc_driver_init(void) __attribute__((__section__(".init.text"),
5091__no_instrument_function__)) ;
5092#line 374 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5093static int stk17ta8_rtc_driver_init(void)
5094{ int tmp ;
5095
5096 {
5097 {
5098#line 374
5099 tmp = platform_driver_register(& stk17ta8_rtc_driver);
5100 }
5101#line 374
5102 return (tmp);
5103}
5104}
5105#line 374 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5106int init_module(void)
5107{ int tmp ;
5108
5109 {
5110 {
5111#line 374
5112 tmp = stk17ta8_rtc_driver_init();
5113 }
5114#line 374
5115 return (tmp);
5116}
5117}
5118#line 374
5119static void stk17ta8_rtc_driver_exit(void) __attribute__((__section__(".exit.text"),
5120__no_instrument_function__)) ;
5121#line 374 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5122static void stk17ta8_rtc_driver_exit(void)
5123{
5124
5125 {
5126 {
5127#line 374
5128 platform_driver_unregister(& stk17ta8_rtc_driver);
5129 }
5130#line 374
5131 return;
5132}
5133}
5134#line 374 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5135void cleanup_module(void)
5136{
5137
5138 {
5139 {
5140#line 374
5141 stk17ta8_rtc_driver_exit();
5142 }
5143#line 374
5144 return;
5145}
5146}
5147#line 376 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5148static char const __mod_author376[44] __attribute__((__used__, __unused__, __section__(".modinfo"),
5149__aligned__(1))) =
5150#line 376
5151 { (char const )'a', (char const )'u', (char const )'t', (char const )'h',
5152 (char const )'o', (char const )'r', (char const )'=', (char const )'T',
5153 (char const )'h', (char const )'o', (char const )'m', (char const )'a',
5154 (char const )'s', (char const )' ', (char const )'H', (char const )'o',
5155 (char const )'m', (char const )'m', (char const )'e', (char const )'l',
5156 (char const )' ', (char const )'<', (char const )'t', (char const )'h',
5157 (char const )'o', (char const )'m', (char const )'a', (char const )'s',
5158 (char const )'.', (char const )'h', (char const )'o', (char const )'m',
5159 (char const )'m', (char const )'e', (char const )'l', (char const )'@',
5160 (char const )'g', (char const )'e', (char const )'.', (char const )'c',
5161 (char const )'o', (char const )'m', (char const )'>', (char const )'\000'};
5162#line 377 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5163static char const __mod_description377[39] __attribute__((__used__, __unused__,
5164__section__(".modinfo"), __aligned__(1))) =
5165#line 377
5166 { (char const )'d', (char const )'e', (char const )'s', (char const )'c',
5167 (char const )'r', (char const )'i', (char const )'p', (char const )'t',
5168 (char const )'i', (char const )'o', (char const )'n', (char const )'=',
5169 (char const )'S', (char const )'i', (char const )'m', (char const )'t',
5170 (char const )'e', (char const )'k', (char const )' ', (char const )'S',
5171 (char const )'T', (char const )'K', (char const )'1', (char const )'7',
5172 (char const )'T', (char const )'A', (char const )'8', (char const )' ',
5173 (char const )'R', (char const )'T', (char const )'C', (char const )' ',
5174 (char const )'d', (char const )'r', (char const )'i', (char const )'v',
5175 (char const )'e', (char const )'r', (char const )'\000'};
5176#line 378 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5177static char const __mod_license378[12] __attribute__((__used__, __unused__, __section__(".modinfo"),
5178__aligned__(1))) =
5179#line 378
5180 { (char const )'l', (char const )'i', (char const )'c', (char const )'e',
5181 (char const )'n', (char const )'s', (char const )'e', (char const )'=',
5182 (char const )'G', (char const )'P', (char const )'L', (char const )'\000'};
5183#line 379 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5184static char const __mod_version379[12] __attribute__((__used__, __unused__, __section__(".modinfo"),
5185__aligned__(1))) =
5186#line 379
5187 { (char const )'v', (char const )'e', (char const )'r', (char const )'s',
5188 (char const )'i', (char const )'o', (char const )'n', (char const )'=',
5189 (char const )'0', (char const )'.', (char const )'1', (char const )'\000'};
5190#line 397
5191void ldv_check_final_state(void) ;
5192#line 400
5193extern void ldv_check_return_value(int res ) ;
5194#line 403
5195extern void ldv_initialize(void) ;
5196#line 406
5197extern int __VERIFIER_nondet_int(void) ;
5198#line 409 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5199int LDV_IN_INTERRUPT ;
5200#line 702 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5201static int res_stk17ta8_rtc_probe_9 ;
5202#line 412 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5203void main(void)
5204{ struct device *var_group1 ;
5205 struct rtc_time *var_group2 ;
5206 struct rtc_wkalrm *var_group3 ;
5207 unsigned int var_stk17ta8_rtc_alarm_irq_enable_6_p1 ;
5208 struct file *var_group4 ;
5209 struct kobject *var_group5 ;
5210 struct bin_attribute *var_stk17ta8_nvram_read_7_p2 ;
5211 char *var_stk17ta8_nvram_read_7_p3 ;
5212 loff_t var_stk17ta8_nvram_read_7_p4 ;
5213 size_t var_stk17ta8_nvram_read_7_p5 ;
5214 struct bin_attribute *var_stk17ta8_nvram_write_8_p2 ;
5215 char *var_stk17ta8_nvram_write_8_p3 ;
5216 loff_t var_stk17ta8_nvram_write_8_p4 ;
5217 size_t var_stk17ta8_nvram_write_8_p5 ;
5218 struct platform_device *var_group6 ;
5219 int var_stk17ta8_rtc_interrupt_5_p0 ;
5220 void *var_stk17ta8_rtc_interrupt_5_p1 ;
5221 int ldv_s_stk17ta8_rtc_driver_platform_driver ;
5222 int tmp ;
5223 int tmp___0 ;
5224 int __cil_tmp21 ;
5225
5226 {
5227 {
5228#line 747
5229 LDV_IN_INTERRUPT = 1;
5230#line 756
5231 ldv_initialize();
5232#line 761
5233 ldv_s_stk17ta8_rtc_driver_platform_driver = 0;
5234 }
5235 {
5236#line 766
5237 while (1) {
5238 while_continue: ;
5239 {
5240#line 766
5241 tmp___0 = __VERIFIER_nondet_int();
5242 }
5243#line 766
5244 if (tmp___0) {
5245
5246 } else {
5247 {
5248#line 766
5249 __cil_tmp21 = ldv_s_stk17ta8_rtc_driver_platform_driver == 0;
5250#line 766
5251 if (! __cil_tmp21) {
5252
5253 } else {
5254#line 766
5255 goto while_break;
5256 }
5257 }
5258 }
5259 {
5260#line 770
5261 tmp = __VERIFIER_nondet_int();
5262 }
5263#line 772
5264 if (tmp == 0) {
5265#line 772
5266 goto case_0;
5267 } else
5268#line 817
5269 if (tmp == 1) {
5270#line 817
5271 goto case_1;
5272 } else
5273#line 862
5274 if (tmp == 2) {
5275#line 862
5276 goto case_2;
5277 } else
5278#line 907
5279 if (tmp == 3) {
5280#line 907
5281 goto case_3;
5282 } else
5283#line 952
5284 if (tmp == 4) {
5285#line 952
5286 goto case_4;
5287 } else
5288#line 997
5289 if (tmp == 5) {
5290#line 997
5291 goto case_5;
5292 } else
5293#line 1042
5294 if (tmp == 6) {
5295#line 1042
5296 goto case_6;
5297 } else
5298#line 1087
5299 if (tmp == 7) {
5300#line 1087
5301 goto case_7;
5302 } else
5303#line 1135
5304 if (tmp == 8) {
5305#line 1135
5306 goto case_8;
5307 } else {
5308 {
5309#line 1180
5310 goto switch_default;
5311#line 770
5312 if (0) {
5313 case_0:
5314 {
5315#line 809
5316 stk17ta8_rtc_read_time(var_group1, var_group2);
5317 }
5318#line 816
5319 goto switch_break;
5320 case_1:
5321 {
5322#line 854
5323 stk17ta8_rtc_set_time(var_group1, var_group2);
5324 }
5325#line 861
5326 goto switch_break;
5327 case_2:
5328 {
5329#line 899
5330 stk17ta8_rtc_read_alarm(var_group1, var_group3);
5331 }
5332#line 906
5333 goto switch_break;
5334 case_3:
5335 {
5336#line 944
5337 stk17ta8_rtc_set_alarm(var_group1, var_group3);
5338 }
5339#line 951
5340 goto switch_break;
5341 case_4:
5342 {
5343#line 989
5344 stk17ta8_rtc_alarm_irq_enable(var_group1, var_stk17ta8_rtc_alarm_irq_enable_6_p1);
5345 }
5346#line 996
5347 goto switch_break;
5348 case_5:
5349 {
5350#line 1034
5351 stk17ta8_nvram_read(var_group4, var_group5, var_stk17ta8_nvram_read_7_p2,
5352 var_stk17ta8_nvram_read_7_p3, var_stk17ta8_nvram_read_7_p4,
5353 var_stk17ta8_nvram_read_7_p5);
5354 }
5355#line 1041
5356 goto switch_break;
5357 case_6:
5358 {
5359#line 1079
5360 stk17ta8_nvram_write(var_group4, var_group5, var_stk17ta8_nvram_write_8_p2,
5361 var_stk17ta8_nvram_write_8_p3, var_stk17ta8_nvram_write_8_p4,
5362 var_stk17ta8_nvram_write_8_p5);
5363 }
5364#line 1086
5365 goto switch_break;
5366 case_7:
5367#line 1090
5368 if (ldv_s_stk17ta8_rtc_driver_platform_driver == 0) {
5369 {
5370#line 1124
5371 res_stk17ta8_rtc_probe_9 = stk17ta8_rtc_probe(var_group6);
5372#line 1125
5373 ldv_check_return_value(res_stk17ta8_rtc_probe_9);
5374 }
5375#line 1126
5376 if (res_stk17ta8_rtc_probe_9) {
5377#line 1127
5378 goto ldv_module_exit;
5379 } else {
5380
5381 }
5382#line 1128
5383 ldv_s_stk17ta8_rtc_driver_platform_driver = 0;
5384 } else {
5385
5386 }
5387#line 1134
5388 goto switch_break;
5389 case_8:
5390 {
5391#line 1138
5392 LDV_IN_INTERRUPT = 2;
5393#line 1172
5394 stk17ta8_rtc_interrupt(var_stk17ta8_rtc_interrupt_5_p0, var_stk17ta8_rtc_interrupt_5_p1);
5395#line 1173
5396 LDV_IN_INTERRUPT = 1;
5397 }
5398#line 1179
5399 goto switch_break;
5400 switch_default:
5401#line 1180
5402 goto switch_break;
5403 } else {
5404 switch_break: ;
5405 }
5406 }
5407 }
5408 }
5409 while_break: ;
5410 }
5411 ldv_module_exit:
5412 {
5413#line 1189
5414 ldv_check_final_state();
5415 }
5416#line 1192
5417 return;
5418}
5419}
5420#line 5 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/engine-blast-assert.h"
5421void ldv_blast_assert(void)
5422{
5423
5424 {
5425 ERROR:
5426#line 6
5427 goto ERROR;
5428}
5429}
5430#line 6 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/engine-blast.h"
5431extern int __VERIFIER_nondet_int(void) ;
5432#line 19 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5433int ldv_mutex = 1;
5434#line 22 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5435int __attribute__((__warn_unused_result__)) mutex_lock_interruptible(struct mutex *lock )
5436{ int nondetermined ;
5437
5438 {
5439#line 29
5440 if (ldv_mutex == 1) {
5441
5442 } else {
5443 {
5444#line 29
5445 ldv_blast_assert();
5446 }
5447 }
5448 {
5449#line 32
5450 nondetermined = __VERIFIER_nondet_int();
5451 }
5452#line 35
5453 if (nondetermined) {
5454#line 38
5455 ldv_mutex = 2;
5456#line 40
5457 return (0);
5458 } else {
5459#line 45
5460 return (-4);
5461 }
5462}
5463}
5464#line 50 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5465int __attribute__((__warn_unused_result__)) mutex_lock_killable(struct mutex *lock )
5466{ int nondetermined ;
5467
5468 {
5469#line 57
5470 if (ldv_mutex == 1) {
5471
5472 } else {
5473 {
5474#line 57
5475 ldv_blast_assert();
5476 }
5477 }
5478 {
5479#line 60
5480 nondetermined = __VERIFIER_nondet_int();
5481 }
5482#line 63
5483 if (nondetermined) {
5484#line 66
5485 ldv_mutex = 2;
5486#line 68
5487 return (0);
5488 } else {
5489#line 73
5490 return (-4);
5491 }
5492}
5493}
5494#line 78 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5495int atomic_dec_and_mutex_lock(atomic_t *cnt , struct mutex *lock )
5496{ int atomic_value_after_dec ;
5497
5498 {
5499#line 83
5500 if (ldv_mutex == 1) {
5501
5502 } else {
5503 {
5504#line 83
5505 ldv_blast_assert();
5506 }
5507 }
5508 {
5509#line 86
5510 atomic_value_after_dec = __VERIFIER_nondet_int();
5511 }
5512#line 89
5513 if (atomic_value_after_dec == 0) {
5514#line 92
5515 ldv_mutex = 2;
5516#line 94
5517 return (1);
5518 } else {
5519
5520 }
5521#line 98
5522 return (0);
5523}
5524}
5525#line 103 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5526void mutex_lock(struct mutex *lock )
5527{
5528
5529 {
5530#line 108
5531 if (ldv_mutex == 1) {
5532
5533 } else {
5534 {
5535#line 108
5536 ldv_blast_assert();
5537 }
5538 }
5539#line 110
5540 ldv_mutex = 2;
5541#line 111
5542 return;
5543}
5544}
5545#line 114 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5546int mutex_trylock(struct mutex *lock )
5547{ int nondetermined ;
5548
5549 {
5550#line 121
5551 if (ldv_mutex == 1) {
5552
5553 } else {
5554 {
5555#line 121
5556 ldv_blast_assert();
5557 }
5558 }
5559 {
5560#line 124
5561 nondetermined = __VERIFIER_nondet_int();
5562 }
5563#line 127
5564 if (nondetermined) {
5565#line 130
5566 ldv_mutex = 2;
5567#line 132
5568 return (1);
5569 } else {
5570#line 137
5571 return (0);
5572 }
5573}
5574}
5575#line 142 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5576void mutex_unlock(struct mutex *lock )
5577{
5578
5579 {
5580#line 147
5581 if (ldv_mutex == 2) {
5582
5583 } else {
5584 {
5585#line 147
5586 ldv_blast_assert();
5587 }
5588 }
5589#line 149
5590 ldv_mutex = 1;
5591#line 150
5592 return;
5593}
5594}
5595#line 153 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/kernel-rules/files/model0032.c"
5596void ldv_check_final_state(void)
5597{
5598
5599 {
5600#line 156
5601 if (ldv_mutex == 1) {
5602
5603 } else {
5604 {
5605#line 156
5606 ldv_blast_assert();
5607 }
5608 }
5609#line 157
5610 return;
5611}
5612}
5613#line 1201 "/home/zakharov/launch/work/current--X--drivers/--X--defaultlinux-3.4--X--32_1--X--cpachecker/linux-3.4/csd_deg_dscv/6261/dscv_tempdir/dscv/ri/32_1/drivers/rtc/rtc-stk17ta8.c.common.c"
5614long s__builtin_expect(long val , long res )
5615{
5616
5617 {
5618#line 1202
5619 return (val);
5620}
5621}